@autorest/python 6.4.15 → 6.5.1

package/autorest/codegen/models/credential_types.py

@@ -73,19 +73,29 @@ class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
 
 class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel", key: str
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        key: str,
+        scheme: Optional[str] = None,
     ) -> None:
         super().__init__(yaml_data, code_model)
         self.key = key
+        self.scheme = scheme
 
     def call(self, async_mode: bool) -> str:
-        return f'policies.AzureKeyCredentialPolicy(self.credential, "{self.key}", **kwargs)'
+        params = f'"{self.key}", '
+        if self.scheme:
+            params += f'prefix="{self.scheme}", '
+        return f"policies.AzureKeyCredentialPolicy(self.credential, {params}**kwargs)"
 
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "AzureKeyCredentialPolicyType":
-        return cls(yaml_data, code_model, yaml_data["key"])
+        return cls(
+            yaml_data, code_model, yaml_data["key"], yaml_data.get("scheme", None)
+        )
 
 
 CredentialPolicyType = TypeVar(

package/autorest/codegen/serializers/__init__.py

@@ -29,7 +29,11 @@ from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
 from .types_serializer import TypesSerializer
 from ..._utils import to_snake_case
-from .utils import extract_sample_name
+from .utils import (
+    extract_sample_name,
+    get_namespace_from_package_name,
+    get_namespace_config,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -547,18 +551,35 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             namespace_path / Path("_metadata.json"), metadata_serializer.serialize()
         )
 
+    @property
+    def _namespace_from_package_name(self) -> str:
+        return get_namespace_from_package_name(self.code_model.options["package_name"])
+
     def _name_space(self) -> str:
-        if self.code_model.namespace.count(".") >= (
-            self.code_model.options["package_name"] or ""
-        ).count("-"):
+        if self.code_model.namespace.count(
+            "."
+        ) >= self._namespace_from_package_name.count("."):
             return self.code_model.namespace
 
-        return self.code_model.options["package_name"].replace("-", ".")
+        return self._namespace_from_package_name
 
     # find root folder where "setup.py" is
     def _package_root_folder(self, namespace_path: Path) -> Path:
         return namespace_path / Path("../" * (self._name_space().count(".") + 1))
 
+    @property
+    def _additional_folder(self) -> Path:
+        namespace_config = get_namespace_config(
+            self.code_model.namespace, self.code_model.options["multiapi"]
+        )
+        num_of_namespace = namespace_config.count(".") + 1
+        num_of_package_namespace = self._namespace_from_package_name.count(".") + 1
+        if num_of_namespace > num_of_package_namespace:
+            return Path(
+                "/".join(namespace_config.split(".")[num_of_package_namespace:])
+            )
+        return Path("")
+
     def _serialize_and_write_sample(self, env: Environment, namespace_path: Path):
         out_path = self._package_root_folder(namespace_path) / Path("generated_samples")
         for client in self.code_model.clients:
@@ -578,7 +599,10 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                         file_name = to_snake_case(extract_sample_name(file)) + ".py"
                         try:
                             self.write_file(
-                                out_path / _sample_output_path(file) / file_name,
+                                out_path
+                                / self._additional_folder
+                                / _sample_output_path(file)
+                                / file_name,
                                 SampleSerializer(
                                     code_model=self.code_model,
                                     env=env,

package/autorest/codegen/serializers/sample_serializer.py

@@ -16,6 +16,8 @@ from autorest.codegen.models.operation_group import OperationGroup
 from autorest.codegen.models.parameter import Parameter, BodyParameter
 from autorest.codegen.serializers.import_serializer import FileImportSerializer
 from ..models import CodeModel
+from .utils import get_namespace_config, get_namespace_from_package_name
+from ..._utils import to_snake_case
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,12 +38,24 @@ class SampleSerializer:
         self.operation = operation
         self.sample = sample
         self.file_name = file_name
+        self.sample_params = {
+            to_snake_case(k): v for k, v in sample.get("parameters", {}).items()
+        }
 
     def _imports(self) -> FileImportSerializer:
         imports = FileImport()
-        namespace = (self.code_model.options["package_name"] or "").replace(
-            "-", "."
-        ) or self.code_model.namespace
+        namespace_from_package_name = get_namespace_from_package_name(
+            self.code_model.options["package_name"]
+        )
+        namespace_config = get_namespace_config(
+            self.code_model.namespace, self.code_model.options["multiapi"]
+        )
+        namespace = namespace_from_package_name or namespace_config
+        # mainly for "azure-mgmt-rdbms"
+        if not self.code_model.options["multiapi"] and namespace_config.count(
+            "."
+        ) > namespace_from_package_name.count("."):
+            namespace = namespace_config
         client = self.code_model.clients[0]
         imports.add_submodule_import(namespace, client.name, ImportType.THIRDPARTY)
         credential_type = getattr(client.credential, "type", None)
@@ -58,7 +72,7 @@ class SampleSerializer:
             if (
                 not param.client_default_value
                 and not param.optional
-                and param.wire_name in self.sample["parameters"]
+                and param.client_name in self.sample_params
             ):
                 imports.merge(param.type.imports_for_sample())
         return FileImportSerializer(imports, True)
@@ -82,7 +96,7 @@ class SampleSerializer:
         client_params = {
             p.client_name: special_param.get(
                 p.client_name,
-                f'"{self.sample["parameters"].get(p.wire_name) or p.client_name.upper()}"',
+                f'"{self.sample_params.get(p.client_name) or p.client_name.upper()}"',
             )
             for p in params_positional
         }
@@ -107,8 +121,8 @@ class SampleSerializer:
         failure_info = "fail to find required param named {}"
         operation_params = {}
         for param in params_positional:
-            name = param.wire_name
-            param_value = self.sample["parameters"].get(name)
+            name = param.client_name
+            param_value = self.sample_params.get(name)
             if not param.optional:
                 if not param_value:
                     raise Exception(failure_info.format(name))

package/autorest/codegen/serializers/utils.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import Optional
 from pathlib import Path
 
 
@@ -17,3 +18,15 @@ def method_signature_and_response_type_annotation_template(
 def extract_sample_name(file_path: str) -> str:
     file = file_path.split("specification")[-1]
     return Path(file).parts[-1].replace(".json", "")
+
+
+def strip_end(namespace: str) -> str:
+    return ".".join(namespace.split(".")[:-1])
+
+
+def get_namespace_config(namespace: str, multiapi: bool) -> str:
+    return strip_end(namespace) if multiapi else namespace
+
+
+def get_namespace_from_package_name(package_name: Optional[str]) -> str:
+    return (package_name or "").replace("-", ".")

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

@@ -90,7 +90,7 @@ setup(
         {% if azure_arm %}
         "azure-mgmt-core<2.0.0,>=1.3.2",
         {% else %}
-        "azure-core<2.0.0,>=1.24.0",
+        "azure-core<2.0.0,>=1.27.0",
         {% endif %}
         {% if code_model.need_typing_extensions %}
         "typing-extensions>=4.3.0; python_version<'3.8.0'",

package/autorest/m4reformatter/__init__.py

@@ -128,6 +128,7 @@ def update_property(
             op["language"]["default"]["name"].lstrip("_")  # TODO: patching m4
             for op in yaml_data.get("originalParameter", [])
         ],
+        "clientDefaultValue": yaml_data.get("clientDefaultValue"),
     }
 
 
@@ -498,6 +499,9 @@ class M4Reformatter(
             overload = self.update_overload(
                 group_name, yaml_data, body_type, content_types=content_types
             )
+            overload["internal"] = yaml_data.get("extensions", {}).get(
+                "x-ms-internal", False
+            )
             for parameter in overload["parameters"]:
                 if parameter["wireName"].lower() == "content-type":
                     parameter["clientDefaultValue"] = overload["bodyParameter"][
@@ -579,6 +583,9 @@ class M4Reformatter(
         )
         content_types = None
         operation = self._update_operation_helper(group_name, yaml_data, body_parameter)
+        operation["internal"] = yaml_data.get("extensions", {}).get(
+            "x-ms-internal", False
+        )
         operation["overloads"] = self.update_overloads(
             group_name, yaml_data, body_parameter, content_types=content_types
         )

package/package.json

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