@autorest/python 6.13.7 → 6.13.9

package/autorest/codegen/__init__.py

@@ -38,6 +38,7 @@ class OptionsRetriever:
         "polymorphic-examples": 5,
         "generate-sample": False,
         "from-typespec": False,
+        "emit-cross-language-definition-file": False,
     }
 
     @property
@@ -333,6 +334,7 @@ class CodeGenerator(Plugin):
             "from_typespec",
             "flavor",
             "company_name",
+            "emit_cross_language_definition_file",
         ]
         return {f: getattr(self.options_retriever, f) for f in flags}
 

package/autorest/codegen/models/code_model.py

@@ -75,6 +75,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self.named_unions: List[CombinedType] = [
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
+        self.cross_language_package_id = self.yaml_data.get("crossLanguagePackageId")
 
     @property
     def has_form_data(self) -> bool:

package/autorest/codegen/models/constant_type.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any, Optional, TYPE_CHECKING
+from typing import Dict, Any, Optional, TYPE_CHECKING, Union
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 from .primitive_types import IntegerType, BinaryType, StringType, BooleanType
@@ -31,7 +31,7 @@ class ConstantType(BaseType):
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
         value_type: BaseType,
-        value: Optional[str],
+        value: Optional[Union[str, int, float]],
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.value_type = value_type

package/autorest/codegen/models/enum_type.py

@@ -101,11 +101,10 @@ class EnumValue(BaseType):
         """
         from . import build_type
 
-        enum_type = cast(EnumType, code_model.lookup_type(id(yaml_data["enumType"])))
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
-            enum_type=enum_type,
+            enum_type=cast(EnumType, build_type(yaml_data["enumType"], code_model)),
             value_type=build_type(yaml_data["valueType"], code_model),
         )
 
@@ -134,6 +133,9 @@ class EnumType(BaseType):
         self.values = values
         self.value_type = value_type
         self.internal: bool = self.yaml_data.get("internal", False)
+        self.cross_language_definition_id: Optional[str] = self.yaml_data.get(
+            "crossLanguageDefinitionId"
+        )
 
     def __lt__(self, other):
         return self.name.lower() < other.name.lower()

package/autorest/codegen/models/model_type.py

@@ -75,6 +75,9 @@ class ModelType(  # pylint: disable=abstract-method
         self.internal: bool = self.yaml_data.get("internal", False)
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
         self.page_result_model: bool = self.yaml_data.get("pageResultModel", False)
+        self.cross_language_definition_id: Optional[str] = self.yaml_data.get(
+            "crossLanguageDefinitionId"
+        )
 
     @property
     def flattened_property(self) -> Optional[Property]:

package/autorest/codegen/models/operation.py

@@ -54,7 +54,7 @@ def is_internal(target: Optional[BaseType]) -> bool:
     return isinstance(target, ModelType) and target.base == "dpg" and target.internal
 
 
-class OperationBase(  # pylint: disable=too-many-public-methods
+class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instance-attributes
     Generic[ResponseType], BaseBuilder[ParameterList, List["Operation"]]
 ):
     def __init__(
@@ -91,6 +91,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.internal:
             self.name = "_" + self.name
         self.has_etag: bool = self.yaml_data.get("hasEtag", False)
+        self.cross_language_definition_id: Optional[str] = self.yaml_data.get(
+            "crossLanguageDefinitionId"
+        )
 
     @property
     def has_form_data_body(self):
@@ -386,6 +389,18 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.add_submodule_import(
                 "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.SDKCORE
             )
+        file_import.add_submodule_import(
+            "typing",
+            "Type",
+            ImportType.STDLIB,
+        )
+        file_import.add_mutable_mapping_import()
+        if self.non_default_error_status_codes:
+            file_import.add_submodule_import(
+                "typing",
+                "cast",
+                ImportType.STDLIB,
+            )
 
         if self.has_kwargs_to_pop_with_default(
             self.parameters.kwargs_to_pop, ParameterLocation.HEADER  # type: ignore
@@ -478,6 +493,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         )
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
+        if self.non_default_errors and self.code_model.options["models_mode"] == "dpg":
+            file_import.add_submodule_import(
+                f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL
+            )
         return file_import
 
     def get_response_from_status(

package/autorest/codegen/models/parameter.py

@@ -63,7 +63,7 @@ class _ParameterBase(
         type: BaseType,
     ) -> None:
         super().__init__(yaml_data, code_model)
-        self.wire_name: str = yaml_data["wireName"]
+        self.wire_name: str = yaml_data.get("wireName", "")
         self.client_name: str = self.yaml_data["clientName"]
         self.optional: bool = self.yaml_data["optional"]
         self.location: ParameterLocation = self.yaml_data["location"]
@@ -373,7 +373,7 @@ class Parameter(_ParameterBase):
             return ParameterMethodLocation.KEYWORD_ONLY
         if self.grouper:
             return ParameterMethodLocation.POSITIONAL
-        if self.constant:
+        if self.constant and self.wire_name != "Content-Type":
             return ParameterMethodLocation.KWARG
         if self.is_content_type:
             if self.in_overload:

package/autorest/codegen/models/response.py

@@ -37,10 +37,12 @@ class ResponseHeader(BaseModel):
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "ResponseHeader":
+        from . import build_type
+
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
+            type=build_type(yaml_data["type"], code_model),
         )
 
 

package/autorest/codegen/serializers/__init__.py

@@ -522,6 +522,11 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 namespace_path / Path("_validation.py"),
                 general_serializer.serialize_validation_file(),
             )
+        if self.code_model.options.get("emit_cross_language_definition_file"):
+            self.write_file(
+                namespace_path / Path("apiview_mapping_python.json"),
+                general_serializer.serialize_cross_language_definition_file(),
+            )
 
         # Write the setup file
         if self.code_model.options["basic_setup_py"]:

package/autorest/codegen/serializers/builder_serializer.py

@@ -639,6 +639,7 @@ class _OperationSerializer(
                 discriminator_name = cast(
                     Property, polymorphic_subtypes[0].discriminator
                 ).wire_name
+                retval.append("")
                 retval.append(
                     "# The response is polymorphic. The following are possible polymorphic "
                     f'responses based off discriminator "{discriminator_name}":'
@@ -1280,7 +1281,7 @@ class _OperationSerializer(
         return retval
 
     def error_map(self, builder: OperationType) -> List[str]:
-        retval = ["error_map = {"]
+        retval = ["error_map: MutableMapping[int, Type[HttpResponseError]] = {"]
         if builder.non_default_errors:
             if not 401 in builder.non_default_error_status_codes:
                 retval.append("    401: ClientAuthenticationError,")
@@ -1308,30 +1309,35 @@ class _OperationSerializer(
                 for status_code in excep.status_codes:
                     if status_code == 401:
                         retval.append(
-                            "    401: lambda response: ClientAuthenticationError(response=response"
-                            f"{error_model_str}{error_format_str}),"
+                            "    401:  cast(Type[HttpResponseError], "
+                            "lambda response: ClientAuthenticationError(response=response"
+                            f"{error_model_str}{error_format_str})),"
                         )
                     elif status_code == 404:
                         retval.append(
-                            "    404: lambda response: ResourceNotFoundError(response=response"
-                            f"{error_model_str}{error_format_str}),"
+                            "    404:  cast(Type[HttpResponseError], "
+                            "lambda response: ResourceNotFoundError(response=response"
+                            f"{error_model_str}{error_format_str})),"
                         )
                     elif status_code == 409:
                         retval.append(
-                            "    409: lambda response: ResourceExistsError(response=response"
-                            f"{error_model_str}{error_format_str}),"
+                            "    409:  cast(Type[HttpResponseError], "
+                            "lambda response: ResourceExistsError(response=response"
+                            f"{error_model_str}{error_format_str})),"
                         )
                     elif status_code == 304:
                         retval.append(
-                            "    304: lambda response: ResourceNotModifiedError(response=response"
-                            f"{error_model_str}{error_format_str}),"
+                            "    304:  cast(Type[HttpResponseError], "
+                            "lambda response: ResourceNotModifiedError(response=response"
+                            f"{error_model_str}{error_format_str})),"
                         )
                     elif not error_model_str and not error_format_str:
                         retval.append(f"    {status_code}: HttpResponseError,")
                     else:
                         retval.append(
-                            f"    {status_code}: lambda response: HttpResponseError(response=response"
-                            f"{error_model_str}{error_format_str}),"
+                            f"    {status_code}: cast(Type[HttpResponseError], "
+                            "lambda response: HttpResponseError(response=response"
+                            f"{error_model_str}{error_format_str})),"
                         )
         else:
             retval.append(

package/autorest/codegen/serializers/general_serializer.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+import json
 from typing import Any, List
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
@@ -196,3 +197,39 @@ class GeneralSerializer(BaseSerializer):
     def serialize_validation_file(self) -> str:
         template = self.env.get_template("validation.py.jinja2")
         return template.render(code_model=self.code_model)
+
+    def serialize_cross_language_definition_file(self) -> str:
+        cross_langauge_def_dict = {
+            f"{self.code_model.namespace}.models.{model.name}": model.cross_language_definition_id
+            for model in self.code_model.model_types
+        }
+        cross_langauge_def_dict.update(
+            {
+                f"{self.code_model.namespace}.models.{enum.name}": enum.cross_language_definition_id
+                for enum in self.code_model.enums
+            }
+        )
+        cross_langauge_def_dict.update(
+            {
+                (
+                    f"{self.code_model.namespace}.{client.name}."
+                    + (
+                        ""
+                        if operation_group.is_mixin
+                        else f"{operation_group.property_name}."
+                    )
+                    + f"{operation.name}"
+                ): operation.cross_language_definition_id
+                for client in self.code_model.clients
+                for operation_group in client.operation_groups
+                for operation in operation_group.operations
+                if not operation.name.startswith("_")
+            }
+        )
+        return json.dumps(
+            {
+                "CrossLanguagePackageId": self.code_model.cross_language_package_id,
+                "CrossLanguageDefinitionId": cross_langauge_def_dict,
+            },
+            indent=4,
+        )

package/autorest/codegen/templates/packaging_templates/README.md.jinja2

@@ -28,7 +28,7 @@ section of the project.
 
 ## Getting started
 
-### Installating the package
+### Install the package
 
 ```bash
 python -m pip install {{ package_name }}

package/autorest/codegen/templates/packaging_templates/setup.py.jinja2

@@ -87,12 +87,12 @@ setup(
         {% if code_model.is_legacy %}
         "msrest>=0.7.1",
         {% else %}
-        "isodate<1.0.0,>=0.6.1",
+        "isodate>=0.6.1",
         {% endif %}
         {% if azure_arm %}
-        "azure-mgmt-core<2.0.0,>=1.3.2",
+        "azure-mgmt-core>=1.3.2",
         {% elif code_model.is_azure_flavor %}
-        "azure-core<2.0.0,>=1.30.0",
+        "azure-core>=1.30.0",
         {% else %}
         "corehttp[requests]",
         {% endif %}

package/autorest/preprocess/__init__.py

@@ -25,15 +25,18 @@ def update_overload_section(
     yaml_data: Dict[str, Any],
     section: str,
 ):
-    for overload_s, original_s in zip(overload[section], yaml_data[section]):
-        if overload_s.get("type"):
-            overload_s["type"] = original_s["type"]
-        if overload_s.get("headers"):
-            for overload_h, original_h in zip(
-                overload_s["headers"], original_s["headers"]
-            ):
-                if overload_h.get("type"):
-                    overload_h["type"] = original_h["type"]
+    try:
+        for overload_s, original_s in zip(overload[section], yaml_data[section]):
+            if overload_s.get("type"):
+                overload_s["type"] = original_s["type"]
+            if overload_s.get("headers"):
+                for overload_h, original_h in zip(
+                    overload_s["headers"], original_s["headers"]
+                ):
+                    if overload_h.get("type"):
+                        overload_h["type"] = original_h["type"]
+    except KeyError as exc:
+        raise ValueError(overload["name"]) from exc
 
 
 def add_overload(
@@ -390,6 +393,11 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             and wire_name_lower in HEADERS_CONVERT_IN_METHOD
         ):
             headers_convert(yaml_data, HEADERS_CONVERT_IN_METHOD[wire_name_lower])
+        if (
+            wire_name_lower in ["$host", "content-type", "accept"]
+            and yaml_data["type"]["type"] == "constant"
+        ):
+            yaml_data["clientDefaultValue"] = yaml_data["type"]["value"]
 
     def update_operation(
         self,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.13.7",
+  "version": "6.13.9",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {