@autorest/python 6.9.0 → 6.9.1

package/autorest/_utils.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, Tuple, List
 import re
 import argparse
 
@@ -105,3 +105,26 @@ KNOWN_TYPES: Dict[str, Dict[str, Any]] = {
 }
 
 JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
+
+
+def build_policies(is_arm: bool, async_mode: bool) -> List[str]:
+    async_prefix = "Async" if async_mode else ""
+    policies = [
+        "policies.RequestIdPolicy(**kwargs)",
+        "self._config.headers_policy",
+        "self._config.user_agent_policy",
+        "self._config.proxy_policy",
+        "policies.ContentDecodePolicy(**kwargs)",
+        f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy()"
+        if is_arm
+        else None,
+        "self._config.redirect_policy",
+        "self._config.retry_policy",
+        "self._config.authentication_policy",
+        "self._config.custom_hook_policy",
+        "self._config.logging_policy",
+        "policies.DistributedTracingPolicy(**kwargs)",
+        "policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None",
+        "self._config.http_logging_policy",
+    ]
+    return [p for p in policies if p]

package/autorest/codegen/models/client.py

@@ -230,7 +230,16 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             MsrestImportType.SerializerDeserializer,
             TypingSection.REGULAR,
         )
-
+        file_import.add_submodule_import(
+            "azure.core.pipeline", "policies", ImportType.AZURECORE
+        )
+        if self.code_model.options["azure_arm"]:
+            async_prefix = "Async" if async_mode else ""
+            file_import.add_submodule_import(
+                "azure.mgmt.core.policies",
+                f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy",
+                ImportType.AZURECORE,
+            )
         return file_import
 
     @property
@@ -239,10 +248,10 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         return any(o for o in self.operation_groups if o.is_mixin)
 
     @property
-    def has_lro_operations(self) -> bool:
+    def has_public_lro_operations(self) -> bool:
         """Are there any LRO operations in this SDK?"""
         return any(
-            operation.operation_type in ("lro", "lropaging")
+            operation.operation_type in ("lro", "lropaging") and not operation.internal
             for operation_group in self.operation_groups
             for operation in operation_group.operations
         )
@@ -398,9 +407,6 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import(
-            "azure.core.configuration", "Configuration", ImportType.AZURECORE
-        )
         file_import.add_submodule_import(
             "azure.core.pipeline", "policies", ImportType.AZURECORE
         )

package/autorest/codegen/models/enum_type.py

@@ -68,6 +68,7 @@ class EnumType(BaseType):
         self.name: str = yaml_data["name"][0].upper() + yaml_data["name"][1:]
         self.values = values
         self.value_type = value_type
+        self.internal: bool = self.yaml_data.get("internal", False)
 
     def __lt__(self, other):
         return self.name.lower() < other.name.lower()

package/autorest/codegen/models/lro_operation.py

@@ -46,7 +46,8 @@ class LROOperationBase(OperationBase[LROResponseType]):
             exceptions=exceptions,
             overloads=overloads,
         )
-        self.name = "begin_" + self.name
+        if not self.name.lstrip("_").startswith("begin"):
+            self.name = ("_begin" if self.internal else "begin_") + self.name
         self.lro_options: Dict[str, Any] = self.yaml_data.get("lroOptions", {})
         self._initial_operation: Optional["OperationType"] = None
 

package/autorest/codegen/models/operation.py

@@ -486,7 +486,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     @property
     def success_status_codes(self) -> List[Union[str, int]]:
         """The list of all successfull status code."""
-        return [code for response in self.responses for code in response.status_codes]
+        return sorted(
+            [code for response in self.responses for code in response.status_codes]
+        )
 
     @property
     def filename(self) -> str:

package/autorest/codegen/serializers/client_serializer.py

@@ -8,6 +8,7 @@ from typing import List
 from . import utils
 from ..models import Client, ParameterMethodLocation
 from .parameter_serializer import ParameterSerializer, PopKwargType
+from ..._utils import build_policies
 
 
 class ClientSerializer:
@@ -72,7 +73,7 @@ class ClientSerializer:
             retval.append(
                 f":{param.docstring_type_keyword} {param.client_name}: {param.docstring_type(async_mode=async_mode)}"
             )
-        if self.client.has_lro_operations:
+        if self.client.has_public_lro_operations:
             retval.append(
                 ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
                 "if no Retry-After header is present."
@@ -107,18 +108,27 @@ class ClientSerializer:
             if og.is_mixin and og.has_abstract_operations
         )
 
-    def initialize_pipeline_client(self, async_mode: bool) -> str:
+    def initialize_pipeline_client(self, async_mode: bool) -> List[str]:
+        result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
         params = {
             "base_url": self.host_variable_name,
-            "config": "self._config",
+            "policies": "_policies",
         }
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:
-            params["request_id_header_name"] = f'"{self.client.request_id_header_name}"'
-        return (
-            f"self._client: {pipeline_client_name} = {pipeline_client_name}("
-            f"{', '.join(f'{k}={v}' for k, v in params.items())}, **kwargs)"
+            result.append(
+                f'kwargs["request_id_header_name"] = "{self.client.request_id_header_name}"'
+            )
+        result.extend(
+            [
+                "_policies = kwargs.pop('policies', None)",
+                "if _policies is None:",
+                f'    _policies = [{",".join(build_policies(self.client.code_model.options["azure_arm"], async_mode))}]',  # pylint: disable=line-too-long
+                f"self._client: {pipeline_client_name} = {pipeline_client_name}("
+                f"{', '.join(f'{k}={v}' for k, v in params.items())}, **kwargs)",
+            ]
         )
+        return result
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []

package/autorest/codegen/serializers/model_init_serializer.py

@@ -16,7 +16,9 @@ class ModelInitSerializer:
         schemas = [s.name for s in self.code_model.public_model_types]
         schemas.sort()
         enums = (
-            [e.name for e in self.code_model.enums] if self.code_model.enums else None
+            [e.name for e in self.code_model.enums if not e.internal]
+            if self.code_model.enums
+            else None
         )
 
         if enums:

package/autorest/codegen/templates/client.py.jinja2

@@ -10,7 +10,7 @@
         {{ serializer.host_variable_name }} = {{ keywords.escape_str(client.url) }}{{ client.url_pylint_disable }}
         {% endif %}
         {{ serializer.initialize_config() }}
-        {{ serializer.initialize_pipeline_client(async_mode) }}
+        {{ op_tools.serialize(serializer.initialize_pipeline_client(async_mode)) | indent(8) }}
 
         {{ op_tools.serialize(serializer.serializers_and_operation_groups_properties()) | indent(8) }}
 

package/autorest/codegen/templates/config.py.jinja2

@@ -1,6 +1,4 @@
-class {{ client.name }}Configuration(  {{ client.config.pylint_disable }}
-    Configuration
-):
+class {{ client.name }}Configuration:  {{ client.config.pylint_disable }}
     """Configuration for {{ client.name }}.
 
     Note that all parameters used to create this instance are saved as instance
@@ -10,7 +8,6 @@ class {{ client.name }}Configuration(  {{ client.config.pylint_disable }}
 {% endif %}
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
-        super({{ client.name }}Configuration, self).__init__(**kwargs)
     {% if client.config.parameters.kwargs_to_pop %}
         {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
     {% endif %}
@@ -34,6 +31,7 @@ class {{ client.name }}Configuration(  {{ client.config.pylint_disable }}
     {% endif %}
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ client.config.sdk_moniker }}/{}'.format(VERSION))
+        self.polling_interval = kwargs.get("polling_interval", 30)
         self._configure(**kwargs)
 
 {% if client.credential and client.credential.type.types is defined %}

package/autorest/codegen/templates/metadata.json.jinja2

@@ -10,7 +10,7 @@
         "host_value": {{ (client.parameters.host.client_default_value_declaration if not client.has_parameterized_host else None) | tojson }},
         "parameterized_host_template": {{ (keywords.escape_str(client.url) if client.has_parameterized_host else None) | tojson }},
         "azure_arm": {{ client.code_model.options["azure_arm"]  | tojson }},
-        "has_lro_operations": {{ client.has_lro_operations | tojson }},
+        "has_public_lro_operations": {{ client.has_public_lro_operations | tojson }},
         "client_side_validation": {{ client.code_model.options["client_side_validation"] | tojson }},
         "sync_imports": {{ sync_client_imports | tojson }},
         "async_imports": {{ async_client_imports | tojson }}

package/autorest/multiapi/models/client.py

@@ -71,12 +71,12 @@ class Client:
         return parameterized_host_template_to_api_version
 
     @property
-    def has_lro_operations(self) -> bool:
-        has_lro_operations = False
+    def has_public_lro_operations(self) -> bool:
+        has_public_lro_operations = False
         for _, metadata_json in self.version_path_to_metadata.items():
-            current_client_has_lro_operations = metadata_json["client"][
-                "has_lro_operations"
+            current_client_has_public_lro_operations = metadata_json["client"][
+                "has_public_lro_operations"
             ]
-            if current_client_has_lro_operations:
-                has_lro_operations = True
-        return has_lro_operations
+            if current_client_has_public_lro_operations:
+                has_public_lro_operations = True
+        return has_public_lro_operations

package/autorest/multiapi/serializers/__init__.py

@@ -12,6 +12,7 @@ from .import_serializer import FileImportSerializer
 from ...jsonrpc import AutorestAPI
 from ..models import CodeModel, GlobalParameter
 from ... import ReaderAndWriter, ReaderAndWriterAutorest
+from ..._utils import build_policies
 
 __all__ = [
     "MultiAPISerializer",
@@ -86,9 +87,12 @@ class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
 
         # serialize service client file
         imports = FileImportSerializer(code_model.client.imports(async_mode))
+        config_policies = build_policies(code_model.azure_arm, async_mode)
         self.write_file(
             _get_file_path(code_model.client.filename, async_mode),
-            _render_template("client", imports=imports),
+            _render_template(
+                "client", imports=imports, config_policies=config_policies
+            ),
         )
 
         # serialize config file

package/autorest/multiapi/templates/multiapi_config.py.jinja2

@@ -28,7 +28,7 @@ def __init__(
 # --------------------------------------------------------------------------
 {{ imports }}
 
-class {{ code_model.client.name }}Configuration(Configuration):
+class {{ code_model.client.name }}Configuration:
     """Configuration for {{ code_model.client.name }}.
 
     Note that all parameters used to create this instance are saved as instance
@@ -49,7 +49,6 @@ class {{ code_model.client.name }}Configuration(Configuration):
             raise ValueError("Parameter '{{ parameter.name }}' must not be None.")
     {% endif %}
 {% endfor %}
-        super({{ code_model.client.name }}Configuration, self).__init__(**kwargs)
 
 {% for parameter in code_model.global_parameters.parameters %}
         self.{{ parameter.name }} = {{ parameter.name }}
@@ -63,6 +62,7 @@ class {{ code_model.client.name }}Configuration(Configuration):
         self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.config.credential_scopes }})
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ code_model.package_name|lower }}/{}'.format(VERSION))
+        self.polling_interval = kwargs.get("polling_interval", 30)
         self._configure(**kwargs)
 
     def _configure(

package/autorest/multiapi/templates/multiapi_service_client.py.jinja2

@@ -60,7 +60,7 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
     :param {{ parameter.name }}: {{ parameter.description(async_mode) }}
     :type {{ parameter.name }}: {{ parameter.docstring_type(async_mode) }}
 {% endfor %}
-    {% if code_model.client.has_lro_operations %}
+    {% if code_model.client.has_public_lro_operations %}
     :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
     {% endif %}
     """
@@ -90,7 +90,14 @@ class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_
         if api_version:
             kwargs.setdefault('api_version', api_version)
         self._config = {{ code_model.client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}**kwargs)
-        self._client = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url={{ code_model.host_variable_name }}, config=self._config, **kwargs)
+        _policies = kwargs.pop("policies", None)
+        if _policies is None:
+            _policies = [
+                {% for p in config_policies %}
+                {{ p }},
+                {% endfor %}
+            ]
+        self._client = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url={{ code_model.host_variable_name }}, policies=_policies, **kwargs)
         super({{ code_model.client.name }}, self).__init__(
             api_version=api_version,
             profile=profile

package/package.json

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