@autorest/python 6.7.2 → 6.7.4

package/autorest/codegen/models/client.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, TYPE_CHECKING, TypeVar, Generic, Union, List, Opti
 from .base import BaseModel
 from .parameter_list import ClientGlobalParameterList, ConfigGlobalParameterList
 from .imports import FileImport, ImportType, TypingSection, MsrestImportType
-from .utils import add_to_pylint_disable
+from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
 from .operation_group import OperationGroup
 from .request_builder import (
     RequestBuilder,
@@ -148,6 +148,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         retval = add_to_pylint_disable("", "client-accepts-api-version-keyword")
         if len(self.operation_groups) > 6:
             retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
+        if len(self.name) > NAME_LENGTH_LIMIT:
+            retval = add_to_pylint_disable(retval, "name-too-long")
         return retval
 
     @property
@@ -371,6 +373,13 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
 class Config(_ClientConfigBase[ConfigGlobalParameterList]):
     """Model representing our Config type."""
 
+    @property
+    def pylint_disable(self) -> str:
+        retval = add_to_pylint_disable("", "too-many-instance-attributes")
+        if len(self.name) + len("Configuration") > NAME_LENGTH_LIMIT:
+            retval = add_to_pylint_disable(retval, "name-too-long")
+        return retval
+
     @property
     def description(self) -> str:
         return (

package/autorest/codegen/models/code_model.py

@@ -133,7 +133,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             return True
         if async_mode:
             return self.need_mixin_abc
-        return self.need_request_converter or self.need_mixin_abc
+        return self.need_request_converter or self.need_mixin_abc or self.has_etag
 
     @property
     def need_request_converter(self) -> bool:

package/autorest/codegen/models/operation.py

@@ -18,7 +18,7 @@ from typing import (
 
 from .request_builder_parameter import RequestBuilderParameter
 
-from .utils import OrderedSet, add_to_pylint_disable
+from .utils import OrderedSet, add_to_pylint_disable, NAME_LENGTH_LIMIT
 from .base_builder import BaseBuilder
 from .imports import FileImport, ImportType, TypingSection
 from .response import (
@@ -143,6 +143,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                 retval = add_to_pylint_disable(retval, "protected-access")
         except ValueError:
             pass
+        if len(self.name) > NAME_LENGTH_LIMIT:
+            retval = add_to_pylint_disable(retval, "name-too-long")
         return retval
 
     def cls_type_annotation(self, *, async_mode: bool) -> str:

package/autorest/codegen/models/operation_group.py

@@ -10,7 +10,7 @@ from autorest.codegen.models.utils import OrderedSet
 from .base import BaseModel
 from .operation import get_operation
 from .imports import FileImport, ImportType, TypingSection
-from .utils import add_to_pylint_disable
+from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -67,6 +67,10 @@ class OperationGroup(BaseModel):
         retval: str = ""
         if self.has_abstract_operations:
             retval = add_to_pylint_disable(retval, "abstract-class-instantiated")
+        if len(self.operations) > 20:
+            retval = add_to_pylint_disable(retval, "too-many-public-methods")
+        if len(self.class_name) > NAME_LENGTH_LIMIT:
+            retval = add_to_pylint_disable(retval, "name-too-long")
         return retval
 
     @property

package/autorest/codegen/models/paging_operation.py

@@ -80,7 +80,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
 
     @property
     def continuation_token_name(self) -> Optional[str]:
-        wire_name = self.yaml_data["continuationTokenName"]
+        wire_name = self.yaml_data.get("continuationTokenName")
         if not wire_name:
             # That's an ok scenario, it just means no next page possible
             return None

package/autorest/codegen/models/primitive_types.py

@@ -358,6 +358,7 @@ class DatetimeType(PrimitiveType):
         self.format = (
             "rfc3339"
             if yaml_data.get("format", "date-time") == "date-time"
+            or yaml_data.get("format", "date-time") == "rfc3339"
             else "rfc7231"
         )
 

package/autorest/codegen/models/request_builder.py

@@ -16,6 +16,7 @@ from typing import (
 from abc import abstractmethod
 
 from .base_builder import BaseBuilder
+from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
 from .parameter_list import (
     RequestBuilderParameterList,
     OverloadedRequestBuilderParameterList,
@@ -56,6 +57,12 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         self.method: str = yaml_data["method"]
         self.want_tracing = False
 
+    @property
+    def pylint_disable(self) -> str:
+        if len(self.name) > NAME_LENGTH_LIMIT:
+            return add_to_pylint_disable("", "name-too-long")
+        return ""
+
     def response_type_annotation(self, **kwargs) -> str:
         return "HttpRequest"
 

package/autorest/codegen/models/utils.py

@@ -8,6 +8,8 @@ from typing import TypeVar, Dict
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+NAME_LENGTH_LIMIT = 40
+
 
 def add_to_description(description: str, entry: str) -> str:
     if description:

package/autorest/codegen/serializers/builder_serializer.py

@@ -751,7 +751,7 @@ class _OperationSerializer(
         elif self.code_model.options["models_mode"] == "dpg":
             create_body_call = (
                 f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
-                "cls=AzureJSONEncoder)  # type: ignore"
+                "cls=AzureJSONEncoder, exclude_readonly=True)  # type: ignore"
             )
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"

package/autorest/codegen/serializers/client_serializer.py

@@ -164,7 +164,7 @@ class ClientSerializer:
                 api_version = ""
             retval.extend(
                 [
-                    f"self.{og.property_name} = {og.class_name}({og.pylint_disable}",
+                    f"self.{og.property_name} = {og.class_name}(",
                     f"    self._client, self._config, self._serialize, self._deserialize{api_version}",
                     ")",
                 ]

package/autorest/codegen/serializers/sample_serializer.py

@@ -125,7 +125,9 @@ class SampleSerializer:
             param_value = self.sample_params.get(name)
             if not param.optional:
                 if not param_value:
-                    raise Exception(failure_info.format(name))
+                    raise Exception(  # pylint: disable=broad-exception-raised
+                        failure_info.format(name)
+                    )
                 operation_params[param.client_name] = self.handle_param(
                     param, param_value
                 )

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

@@ -1,4 +1,6 @@
-class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many-instance-attributes
+class {{ client.name }}Configuration(  {{ client.config.pylint_disable }}
+    Configuration
+):
     """Configuration for {{ client.name }}.
 
     Note that all parameters used to create this instance are saved as instance

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

@@ -128,10 +128,16 @@ def _is_readonly(p):
 class AzureJSONEncoder(JSONEncoder):
     """A JSON encoder that's capable of serializing datetime objects and bytes."""
 
+    def __init__(self, *args, exclude_readonly: bool = False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.exclude_readonly = exclude_readonly
+
     def default(self, o):  # pylint: disable=too-many-return-statements
         if _is_model(o):
-            readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)]
-            return {k: v for k, v in o.items() if k not in readonly_props}
+            if self.exclude_readonly:
+                readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)]
+                return {k: v for k, v in o.items() if k not in readonly_props}
+            return dict(o.items())
         if isinstance(o, (bytes, bytearray)):
             return base64.b64encode(o).decode()
         if isinstance(o, _Null):
@@ -295,11 +301,29 @@ def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] =
     return _DESERIALIZE_MAPPING.get(annotation)
 
 
+def _get_type_alias_type(module_name: str, alias_name: str):
+    types = {
+        k: v
+        for k, v in sys.modules[module_name].__dict__.items()
+        if isinstance(v, typing._GenericAlias)  # type: ignore
+    }
+    if alias_name not in types:
+        return alias_name
+    return types[alias_name]
+
+
 def _get_model(module_name: str, model_name: str):
-    models = {k: v for k, v in sys.modules[module_name].__dict__.items() if isinstance(v, type)}
+    models = {
+        k: v
+        for k, v in sys.modules[module_name].__dict__.items()
+        if isinstance(v, type)
+    }
     module_end = module_name.rsplit(".", 1)[0]
-    module = sys.modules[module_end]
-    models.update({k: v for k, v in module.__dict__.items() if isinstance(v, type)})
+    models.update({
+        k: v
+        for k, v in sys.modules[module_end].__dict__.items()
+        if isinstance(v, type)
+    })
     if isinstance(model_name, str):
         model_name = model_name.split(".")[-1]
     if model_name not in models:
@@ -461,7 +485,7 @@ class Model(_MyMutableMapping):
                 raise TypeError(f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'")
             dict_to_pass.update(
                 {
-                    self._attr_to_rest_field[k]._rest_name: _serialize(v, self._attr_to_rest_field[k]._format)
+                    self._attr_to_rest_field[k]._rest_name: _create_value(self._attr_to_rest_field[k], v)
                     for k, v in kwargs.items()
                     if v is not None
                 }
@@ -499,24 +523,60 @@ class Model(_MyMutableMapping):
                 base.__mapping__[discriminator or cls.__name__] = cls  # type: ignore  # pylint: disable=no-member
 
     @classmethod
-    def _get_discriminator(cls) -> typing.Optional[str]:
+    def _get_discriminator(cls, exist_discriminators) -> typing.Optional[str]:
         for v in cls.__dict__.values():
-            if isinstance(v, _RestField) and v._is_discriminator:  # pylint: disable=protected-access
+            if isinstance(v, _RestField) and v._is_discriminator and v._rest_name not in exist_discriminators:  # pylint: disable=protected-access
                 return v._rest_name  # pylint: disable=protected-access
         return None
 
     @classmethod
-    def _deserialize(cls, data):
+    def _deserialize(cls, data, exist_discriminators):
         if not hasattr(cls, "__mapping__"):  # pylint: disable=no-member
             return cls(data)
-        discriminator = cls._get_discriminator()
-        mapped_cls = cls.__mapping__.get(data.get(discriminator), cls)  # pylint: disable=no-member
+        discriminator = cls._get_discriminator(exist_discriminators)
+        exist_discriminators.append(discriminator)
+        mapped_cls = cls.__mapping__.get(
+            data.get(discriminator), cls
+        )  # pylint: disable=no-member
         if mapped_cls == cls:
             return cls(data)
-        return mapped_cls._deserialize(data)  # pylint: disable=protected-access
-
-
-def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-return-statements, too-many-statements
+        return mapped_cls._deserialize(data, exist_discriminators)  # pylint: disable=protected-access
+
+    def as_dict(self, *, exclude_readonly: bool = False) -> typing.Dict[str, typing.Any]:
+        """Return a dict that can be JSONify using json.dump.
+
+        :keyword bool exclude_readonly: Whether to remove the readonly properties.
+        :returns: A dict JSON compatible object
+        :rtype: dict
+        """
+
+        result = {}
+        if exclude_readonly:
+            readonly_props = [p._rest_name for p in self._attr_to_rest_field.values() if _is_readonly(p)]
+        for k, v in self.items():
+            if exclude_readonly and k in readonly_props:  # pyright: reportUnboundVariable=false
+                continue
+            result[k] = Model._as_dict_value(v, exclude_readonly=exclude_readonly)
+        return result
+
+    @staticmethod
+    def _as_dict_value(v: typing.Any, exclude_readonly: bool = False) -> typing.Any:
+        if v is None or isinstance(v, _Null):
+            return None
+        if isinstance(v, (list, tuple, set)):
+            return [
+                Model._as_dict_value(x, exclude_readonly=exclude_readonly)
+                for x in v
+            ]
+        if isinstance(v, dict):
+            return {
+                dk: Model._as_dict_value(dv, exclude_readonly=exclude_readonly)
+                for dk, dv in v.items()
+            }
+        return v.as_dict(exclude_readonly=exclude_readonly) if hasattr(v, "as_dict") else v
+
+
+def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915, R0912
     annotation: typing.Any,
     module: typing.Optional[str],
     rf: typing.Optional["_RestField"] = None,
@@ -524,8 +584,22 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
     if not annotation or annotation in [int, float]:
         return None
 
+    # is it a type alias?
+    if isinstance(annotation, str):
+        if module is not None:
+            annotation = _get_type_alias_type(module, annotation)
+
+    # is it a forward ref / in quotes?
+    if isinstance(annotation, (str, typing.ForwardRef)):
+        try:
+            model_name = annotation.__forward_arg__  # type: ignore
+        except AttributeError:
+            model_name = annotation
+        if module is not None:
+            annotation = _get_model(module, model_name)
+
     try:
-        if module and _is_model(_get_model(module, annotation)):
+        if module and _is_model(annotation):
             if rf:
                 rf._is_model = True
 
@@ -534,7 +608,7 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
                     return obj
                 return _deserialize(model_deserializer, obj)
 
-            return functools.partial(_deserialize_model, _get_model(module, annotation))
+            return functools.partial(_deserialize_model, annotation)
     except Exception:
         pass
 
@@ -552,22 +626,8 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
     except AttributeError:
         pass
 
-    if getattr(annotation, "__origin__", None) is typing.Union:
-
-        def _deserialize_with_union(union_annotation, obj):
-            for t in union_annotation.__args__:
-                try:
-                    return _deserialize(t, obj, module, rf)
-                except DeserializationError:
-                    pass
-            raise DeserializationError()
-
-        return functools.partial(_deserialize_with_union, annotation)
-
     # is it optional?
     try:
-        # right now, assuming we don't have unions, since we're getting rid of the only
-        # union we used to have in msrest models, which was union of str and enum
         if any(a for a in annotation.__args__ if a == type(None)):
             if_obj_deserializer = _get_deserialize_callable_from_annotation(
                 next(a for a in annotation.__args__ if a != type(None)), module, rf
@@ -582,14 +642,18 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
     except AttributeError:
         pass
 
-    # is it a forward ref / in quotes?
-    if isinstance(annotation, (str, typing.ForwardRef)):
-        try:
-            model_name = annotation.__forward_arg__  # type: ignore
-        except AttributeError:
-            model_name = annotation
-        if module is not None:
-            annotation = _get_model(module, model_name)
+    if getattr(annotation, "__origin__", None) is typing.Union:
+        deserializers = [_get_deserialize_callable_from_annotation(arg, module, rf) for arg in annotation.__args__]
+
+        def _deserialize_with_union(deserializers, obj):
+            for deserializer in deserializers:
+                try:
+                    return _deserialize(deserializer, obj)
+                except DeserializationError:
+                    pass
+            raise DeserializationError()
+
+        return functools.partial(_deserialize_with_union, deserializers)
 
     try:
         if annotation._name == "Dict":
@@ -680,7 +744,7 @@ def _deserialize_with_callable(
                 # for unknown value, return raw value
                 return value
         if isinstance(deserializer, type) and issubclass(deserializer, Model):
-            return deserializer._deserialize(value)
+            return deserializer._deserialize(value, [])
         return typing.cast(typing.Callable[[typing.Any], typing.Any], deserializer)(value)
     except Exception as e:
         raise DeserializationError() from e
@@ -730,6 +794,8 @@ class _RestField:
         item = obj.get(self._rest_name)
         if item is None:
             return item
+        if self._is_model:
+            return item
         return _deserialize(self._type, _serialize(item, self._format), rf=self)
 
     def __set__(self, obj: Model, value) -> None:
@@ -740,8 +806,11 @@ class _RestField:
             except KeyError:
                 pass
             return
-        if self._is_model and not _is_model(value):
-            obj.__setitem__(self._rest_name, _deserialize(self._type, value))
+        if self._is_model:
+            if not _is_model(value):
+                value = _deserialize(self._type, value)
+            obj.__setitem__(self._rest_name, value)
+            return
         obj.__setitem__(self._rest_name, _serialize(value, self._format))
 
     def _get_deserialize_callable_from_annotation(

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

@@ -1,4 +1,3 @@
-{% set disable = "  # pylint: disable=too-many-public-methods" if operation_group.operations | length > 20 else "" %}
 {% set base_class = ("(" + operation_group.base_class + ")") if operation_group.base_class else "" %}
 {% macro check_abstract_methods() %}
 {% if operation_group.has_abstract_operations %}
@@ -9,7 +8,13 @@
         ])
 {% endif %}
 {% endmacro %}
-class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
+{% if operation_group.base_class %}
+class {{ operation_group.class_name }}( {{ operation_group.pylint_disable }}
+    {{ operation_group.base_class }}
+):
+{% else %}
+class {{ operation_group.class_name }}: {{ operation_group.pylint_disable }}
+{% endif %}
 {% if not operation_group.is_mixin %}
     """
     .. warning::

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

@@ -732,6 +732,8 @@ class Serializer(object):
 
             if kwargs.get("skip_quote") is True:
                 output = str(output)
+                # https://github.com/Azure/autorest.python/issues/2063
+                output = output.replace("{", quote("{")).replace("}", quote("}"))
             else:
                 output = quote(str(output), safe="")
         except SerializationError:

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

@@ -13,8 +13,10 @@ def _convert_request(request, files=None):
 {% endif %}
 {% if code_model.need_mixin_abc %}
     {% for client in clients | selectattr("has_mixin") %}
-
-class {{ client.name }}MixinABC(ABC):
+{% set pylint_disable = "# pylint: disable=name-too-long" if (client.name | length) + ("MixinABC" | length) > 40 else "" %}
+class {{ client.name }}MixinABC(  {{ pylint_disable }}
+    ABC
+):
     """DO NOT use this class. It is for internal typing use only."""
     _client: "{{ keywords.async_class }}PipelineClient"
     _config: {{ client.name }}Configuration

package/autorest/jsonrpc/server.py

@@ -82,15 +82,15 @@ def main() -> None:
         "AUTOREST_PYTHON_ATTACH_VSCODE_DEBUG", False
     ):
         try:
-            import ptvsd  # pylint: disable=import-outside-toplevel
+            import debugpy  # pylint: disable=import-outside-toplevel
         except ImportError as exc:
             raise SystemExit(
                 "Please pip install ptvsd in order to use VSCode debugging"
             ) from exc
 
         # 5678 is the default attach port in the VS Code debug configurations
-        ptvsd.enable_attach(address=("localhost", 5678), redirect_output=True)
-        ptvsd.wait_for_attach()
+        debugpy.listen(("localhost", 5678))
+        debugpy.wait_for_client()
         breakpoint()  # pylint: disable=undefined-variable,forgotten-debug-statement
 
     _LOGGER.debug("Starting JSON RPC server")

package/autorest/m4reformatter/__init__.py

@@ -1020,9 +1020,7 @@ class M4Reformatter(
         retval = {
             "type": OAUTH_TYPE,
             "policy": {
-                "type": "ARMChallengeAuthenticationPolicy"
-                if self.azure_arm
-                else "BearerTokenCredentialPolicy",
+                "type": "BearerTokenCredentialPolicy",
                 "credentialScopes": credential_scopes,
             },
         }
@@ -1068,11 +1066,7 @@ class M4Reformatter(
         return credential_scopes
 
     def update_credential_from_flags(self) -> Dict[str, Any]:
-        default_auth_policy = (
-            "ARMChallengeAuthenticationPolicy"
-            if self.azure_arm
-            else "BearerTokenCredentialPolicy"
-        )
+        default_auth_policy = "BearerTokenCredentialPolicy"
         auth_policy = (
             self._autorestapi.get_value("credential-default-policy-type")
             or default_auth_policy

package/autorest/preprocess/__init__.py

@@ -210,6 +210,10 @@ def headers_convert(yaml_data: Dict[str, Any], replace_data: Any) -> None:
 class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
     """Add Python naming information."""
 
+    @property
+    def azure_arm(self) -> bool:
+        return self.options.get("azure-arm", False)
+
     @property
     def version_tolerant(self) -> bool:
         return self.options.get("version-tolerant", True)
@@ -285,6 +289,18 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         yaml_data["legacyFilename"] = to_snake_case(yaml_data["name"].replace(" ", "_"))
         for parameter in yaml_data["parameters"]:
             self.update_parameter(parameter)
+            if parameter["clientName"] == "credential":
+                policy = parameter["type"].get("policy")
+                if (
+                    policy
+                    and policy["type"] == "BearerTokenCredentialPolicy"
+                    and self.azure_arm
+                ):
+                    policy["type"] = "ARMChallengeAuthenticationPolicy"
+                    policy["credentialScopes"] = [
+                        "https://management.azure.com/.default"
+                    ]
+
         prop_name = yaml_data["name"]
         if prop_name.endswith("Client"):
             prop_name = prop_name[: len(prop_name) - len("Client")]
@@ -380,7 +396,6 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             add_overloads_for_body_param(yaml_data)
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:
-        azure_arm = self.options.get("azure-arm", False)
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lro"
             response["pollerSync"] = (
@@ -392,13 +407,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             if not response.get("pollingMethodSync"):
                 response["pollingMethodSync"] = (
                     "azure.mgmt.core.polling.arm_polling.ARMPolling"
-                    if azure_arm
+                    if self.azure_arm
                     else "azure.core.polling.base_polling.LROBasePolling"
                 )
             if not response.get("pollingMethodAsync"):
                 response["pollingMethodAsync"] = (
                     "azure.mgmt.core.polling.async_arm_polling.AsyncARMPolling"
-                    if azure_arm
+                    if self.azure_arm
                     else "azure.core.polling.async_base_polling.AsyncLROBasePolling"
                 )
 

package/package.json

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