@autorest/python 6.2.12 → 6.2.16

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

@@ -4,22 +4,24 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+# pylint: disable=protected-access, arguments-differ, signature-differs, broad-except
+# pyright: reportGeneralTypeIssues=false
 
 import functools
 import sys
 import logging
 import base64
 import re
-import isodate
-from json import JSONEncoder
+import copy
 import typing
-from datetime import datetime, date, time, timedelta
-from azure.core.utils._utils import _FixedOffset
 from collections.abc import MutableMapping
+from datetime import datetime, date, time, timedelta, timezone
+from json import JSONEncoder
+import isodate
 from azure.core.exceptions import DeserializationError
 from azure.core import CaseInsensitiveEnumMeta
 from azure.core.pipeline import PipelineResponse
-import copy
+from azure.core.serialization import NULL as AzureCoreNull
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,11 +43,16 @@ A falsy sentinel object which is supposed to be used to specify attributes
 with no data. This gets serialized to `null` on the wire.
 """
 
+TZ_UTC = timezone.utc
 
 def _timedelta_as_isostr(td: timedelta) -> str:
     """Converts a datetime.timedelta object into an ISO 8601 formatted string, e.g. 'P4DT12H30M05S'
 
     Function adapted from the Tin Can Python project: https://github.com/RusticiSoftware/TinCanPython
+
+    :param timedelta td: The timedelta to convert
+    :rtype: str
+    :return: ISO8601 version of this timedelta
     """
 
     # Split seconds to larger units
@@ -93,7 +100,12 @@ def _timedelta_as_isostr(td: timedelta) -> str:
 
 
 def _datetime_as_isostr(dt: typing.Union[datetime, date, time, timedelta]) -> str:
-    """Converts a datetime.(datetime|date|time|timedelta) object into an ISO 8601 formatted string"""
+    """Converts a datetime.(datetime|date|time|timedelta) object into an ISO 8601 formatted string
+
+    :param timedelta dt: The date object to convert
+    :rtype: str
+    :return: ISO8601 version of this datetime
+    """
     # First try datetime.datetime
     if hasattr(dt, "year") and hasattr(dt, "hour"):
         dt = typing.cast(datetime, dt)
@@ -113,15 +125,6 @@ def _datetime_as_isostr(dt: typing.Union[datetime, date, time, timedelta]) -> st
         dt = typing.cast(timedelta, dt)
         return _timedelta_as_isostr(dt)
 
-
-try:
-    from datetime import timezone
-
-    TZ_UTC = timezone.utc  # type: ignore
-except ImportError:
-    TZ_UTC = _FixedOffset(0)  # type: ignore
-
-
 def _serialize_bytes(o) -> str:
     return base64.b64encode(o).decode()
 
@@ -141,7 +144,7 @@ def _serialize_datetime(o):
 
 def _is_readonly(p):
     try:
-        return p._readonly
+        return p._readonly  # pylint: disable=protected-access
     except AttributeError:
         return False
 
@@ -151,10 +154,12 @@ class AzureJSONEncoder(JSONEncoder):
 
     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)]
+            readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)]  # pylint: disable=protected-access
             return {k: v for k, v in o.items() if k not in readonly_props}
         if isinstance(o, (bytes, bytearray)):
             return base64.b64encode(o).decode()
+        if o is AzureCoreNull:
+            return None
         try:
             return super(AzureJSONEncoder, self).default(o)
         except TypeError:
@@ -174,7 +179,7 @@ class AzureJSONEncoder(JSONEncoder):
             return super(AzureJSONEncoder, self).default(o)
 
 
-_VALID_DATE = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
+_VALID_DATE = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" + r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
 
 
 def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
@@ -182,6 +187,7 @@ def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
 
     :param str attr: response string to be deserialized.
     :rtype: ~datetime.datetime
+    :returns: The datetime object from that input
     """
     if isinstance(attr, datetime):
         # i'm already deserialized
@@ -212,7 +218,8 @@ def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
 def _deserialize_date(attr: typing.Union[str, date]) -> date:
     """Deserialize ISO-8601 formatted string into Date object.
     :param str attr: response string to be deserialized.
-    :rtype: Date
+    :rtype: date
+    :returns: The date object from that input
     """
     # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
     if isinstance(attr, date):
@@ -225,6 +232,7 @@ def _deserialize_time(attr: typing.Union[str, time]) -> time:
 
     :param str attr: response string to be deserialized.
     :rtype: datetime.time
+    :returns: The time object from that input
     """
     if isinstance(attr, time):
         return attr
@@ -258,7 +266,8 @@ def _get_model(module_name: str, model_name: str):
     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)})
-    model_name = model_name.split(".")[-1]
+    if isinstance(model_name, str):
+        model_name = model_name.split(".")[-1]
     if model_name not in models:
         return model_name
     return models[model_name]
@@ -271,7 +280,7 @@ class _MyMutableMapping(MutableMapping):
     def __init__(self, data: typing.Dict[str, typing.Any]) -> None:
         self._data = copy.deepcopy(data)
 
-    def __contains__(self, key: str) -> bool:
+    def __contains__(self, key: typing.Any) -> bool:
         return key in self._data
 
     def __getitem__(self, key: str) -> typing.Any:
@@ -307,15 +316,15 @@ class _MyMutableMapping(MutableMapping):
         except KeyError:
             return default
 
-    @typing.overload
-    def pop(self, key: str) -> typing.Any:
+    @typing.overload  # type: ignore
+    def pop(self, key: str) -> typing.Any:  # pylint: disable=no-member
         ...
 
     @typing.overload
     def pop(self, key: str, default: typing.Any) -> typing.Any:
         ...
 
-    def pop(self, key: typing.Any, default: typing.Any = _UNSET) -> typing.Any:
+    def pop(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
         if default is _UNSET:
             return self._data.pop(key)
         return self._data.pop(key, default)
@@ -329,7 +338,7 @@ class _MyMutableMapping(MutableMapping):
     def update(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         self._data.update(*args, **kwargs)
 
-    @typing.overload
+    @typing.overload  # type: ignore
     def setdefault(self, key: str) -> typing.Any:
         ...
 
@@ -337,7 +346,7 @@ class _MyMutableMapping(MutableMapping):
     def setdefault(self, key: str, default: typing.Any) -> typing.Any:
         ...
 
-    def setdefault(self, key: typing.Any, default: typing.Any = _UNSET) -> typing.Any:
+    def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
         if default is _UNSET:
             return self._data.setdefault(key)
         return self._data.setdefault(key, default)
@@ -383,8 +392,8 @@ def _get_rest_field(
         return None
 
 
-def _create_value(rest_field: typing.Optional["_RestField"], value: typing.Any) -> typing.Any:
-    return _deserialize(rest_field._type, value) if (rest_field and rest_field._is_model) else _serialize(value)
+def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typing.Any:
+    return _deserialize(rf._type, value) if (rf and rf._is_model) else _serialize(value)
 
 
 class Model(_MyMutableMapping):
@@ -414,7 +423,7 @@ class Model(_MyMutableMapping):
     def copy(self):
         return Model(self.__dict__)
 
-    def __new__(cls, *args: typing.Any, **kwargs: typing.Any):
+    def __new__(cls, *args: typing.Any, **kwargs: typing.Any):  # pylint: disable=unused-argument
         # we know the last three classes in mro are going to be 'Model', 'dict', and 'object'
         mros = cls.__mro__[:-3][::-1]  # ignore model, dict, and object parents, and reverse the mro order
         attr_to_rest_field: typing.Dict[str, _RestField] = {  # map attribute name to rest_field property
@@ -423,50 +432,52 @@ class Model(_MyMutableMapping):
         annotations = {
             k: v
             for mro_class in mros
-            if hasattr(mro_class, "__annotations__")
-            for k, v in mro_class.__annotations__.items()
+            if hasattr(mro_class, "__annotations__")  # pylint: disable=no-member
+            for k, v in mro_class.__annotations__.items()  # pylint: disable=no-member
         }
-        for attr, rest_field in attr_to_rest_field.items():
-            rest_field._module = cls.__module__
-            if not rest_field._type:
-                rest_field._type = rest_field._get_deserialize_callable_from_annotation(annotations.get(attr, None))
-            if not rest_field._rest_name_input:
-                rest_field._rest_name_input = attr
-        cls._attr_to_rest_field: typing.Dict[str, _RestField] = {k: v for k, v in attr_to_rest_field.items()}
+        for attr, rf in attr_to_rest_field.items():
+            rf._module = cls.__module__
+            if not rf._type:
+                rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None))
+            if not rf._rest_name_input:
+                rf._rest_name_input = attr
+        cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items())
 
         return super().__new__(cls)
 
     def __init_subclass__(cls, discriminator=None):
         for base in cls.__bases__:
-            if hasattr(base, "__mapping__"):
-                base.__mapping__[discriminator or cls.__name__] = cls
+            if hasattr(base, "__mapping__"):  # pylint: disable=no-member
+                base.__mapping__[discriminator or cls.__name__] = cls  # pylint: disable=no-member
 
     @classmethod
     def _get_discriminator(cls) -> typing.Optional[str]:
         for v in cls.__dict__.values():
-            if isinstance(v, _RestField) and v._is_discriminator:
-                return v._rest_name
+            if isinstance(v, _RestField) and v._is_discriminator:  # pylint: disable=protected-access
+                return v._rest_name  # pylint: disable=protected-access
         return None
 
     @classmethod
     def _deserialize(cls, data):
-        if not hasattr(cls, "__mapping__"):
+        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)
+        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)
+        return mapped_cls._deserialize(data)  # pylint: disable=protected-access
 
 
-def _get_deserialize_callable_from_annotation(
-        annotation: typing.Any, module: str,
+def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-return-statements, too-many-statements
+        annotation: typing.Any, module: typing.Optional[str], rf: "_RestField" = None
     ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
         if not annotation or annotation in [int, float]:
             return None
 
         try:
-            if _is_model(_get_model(module, annotation)):
+            if module and _is_model(_get_model(module, annotation)):
+                if rf:
+                    rf._is_model = True
                 def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj):
                     if _is_model(obj):
                         return obj
@@ -478,21 +489,25 @@ def _get_deserialize_callable_from_annotation(
 
         # is it a literal?
         try:
-            if annotation.__origin__ == typing.Literal:
+            if sys.version_info >= (3, 8):
+                from typing import Literal  # pylint: disable=no-name-in-module, ungrouped-imports
+            else:
+                from typing_extensions import Literal  # type: ignore  # pylint: disable=ungrouped-imports
+
+            if annotation.__origin__ == Literal:
                 return None
         except AttributeError:
             pass
 
-        if isinstance(annotation, typing._GenericAlias):  # pylint: disable=protected-access
-            if annotation.__origin__ is typing.Union:
-                def _deserialize_with_union(union_annotation: typing._GenericAlias, obj):
-                    for t in union_annotation.__args__:
-                        try:
-                            return _deserialize(t, obj, module)
-                        except DeserializationError:
-                            pass
-                    raise DeserializationError()
-                return functools.partial(_deserialize_with_union, annotation)
+        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)
+                    except DeserializationError:
+                        pass
+                raise DeserializationError()
+            return functools.partial(_deserialize_with_union, annotation)
 
         # is it optional?
         try:
@@ -501,7 +516,7 @@ def _get_deserialize_callable_from_annotation(
             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
+                    next(a for a in annotation.__args__ if a != type(None)), module, rf
                 )
 
                 def _deserialize_with_optional(if_obj_deserializer: typing.Optional[typing.Callable], obj):
@@ -510,11 +525,11 @@ def _get_deserialize_callable_from_annotation(
                     return _deserialize_with_callable(if_obj_deserializer, obj)
 
                 return functools.partial(_deserialize_with_optional, if_obj_deserializer)
-        except (AttributeError):
+        except AttributeError:
             pass
 
         # is it a forward ref / in quotes?
-        if isinstance(annotation, str) or type(annotation) == typing.ForwardRef:
+        if isinstance(annotation, (str, typing.ForwardRef)):
             try:
                 model_name = annotation.__forward_arg__  # type: ignore
             except AttributeError:
@@ -524,8 +539,8 @@ def _get_deserialize_callable_from_annotation(
 
         try:
             if annotation._name == "Dict":
-                key_deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[0], module)
-                value_deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[1], module)
+                key_deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[0], module, rf)
+                value_deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[1], module, rf)
 
                 def _deserialize_dict(
                     key_deserializer: typing.Optional[typing.Callable],
@@ -559,10 +574,10 @@ def _get_deserialize_callable_from_annotation(
                         )
 
                     entry_deserializers = [
-                        _get_deserialize_callable_from_annotation(dt, module) for dt in annotation.__args__
+                        _get_deserialize_callable_from_annotation(dt, module, rf) for dt in annotation.__args__
                     ]
                     return functools.partial(_deserialize_multiple_sequence, entry_deserializers)
-                deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[0], module)
+                deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[0], module, rf)
 
                 def _deserialize_sequence(
                     deserializer: typing.Optional[typing.Callable],
@@ -596,6 +611,8 @@ def _deserialize_with_callable(deserializer: typing.Optional[typing.Callable[[ty
     try:
         if value is None:
             return None
+        if deserializer is None:
+            return value
         if isinstance(deserializer, CaseInsensitiveEnumMeta):
             try:
                 return deserializer(value)
@@ -603,13 +620,13 @@ def _deserialize_with_callable(deserializer: typing.Optional[typing.Callable[[ty
                 # for unknown value, return raw value
                 return value
         if isinstance(deserializer, type) and issubclass(deserializer, Model):
-            return deserializer._deserialize(value)
-        return deserializer(value) if deserializer else value
+            return deserializer._deserialize(value)  # type: ignore
+        return deserializer(value)
     except Exception as e:
         raise DeserializationError() from e
 
 
-def _deserialize(deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]], value: typing.Any, module: str = ""):
+def _deserialize(deserializer: typing.Any, value: typing.Any, module: typing.Optional[str] = None) -> typing.Any:
     if isinstance(value, PipelineResponse):
         value = value.http_response.json()
     deserializer = _get_deserialize_callable_from_annotation(deserializer, module)
@@ -662,7 +679,7 @@ class _RestField:
     def _get_deserialize_callable_from_annotation(
         self, annotation: typing.Any
     ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
-        return _get_deserialize_callable_from_annotation(annotation, self._module)
+        return _get_deserialize_callable_from_annotation(annotation, self._module, self)
 
 
 def rest_field(

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

@@ -28,7 +28,7 @@
     """
 
     {% if model.is_polymorphic %}
-    __mapping__ = {}
+    __mapping__: Dict[str, _model_base.Model] = {}
     {% endif %}
     {% for p in serializer.get_properties_to_declare(model)%}
         {% for line in serializer.declare_property(p) %}
@@ -52,11 +52,13 @@
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
-        ...
 
     {% endif %}
-    def __init__(self, *args, **kwargs):
+    {% set initialize_properties = serializer.initialize_properties(model) %}
+    {% if model.is_public and serializer.init_line(model) or initialize_properties %}
+    def __init__(self, *args, **kwargs):{{ '# pylint: disable=useless-super-delegation' if not initialize_properties else '' }}
         super().__init__(*args, **kwargs)
-    {% for initialize_property in serializer.initialize_properties(model) %}
+    {% for initialize_property in initialize_properties %}
         {{ initialize_property }}
     {% endfor %}
+    {% endif %}

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

@@ -50,7 +50,9 @@ from typing import (
     Callable,
     TypeVar,
     MutableMapping,
-    Type
+    Type,
+    List,
+    Mapping,
 )
 
 try:
@@ -62,6 +64,7 @@ import xml.etree.ElementTree as ET
 import isodate  # type: ignore
 
 from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback
+from azure.core.serialization import NULL as AzureCoreNull
 
 _BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
 
@@ -358,7 +361,7 @@ class Model(object):
         ] = attribute_transformer,
         **kwargs: Any
     ) -> JSON:
-        """Return a dict that can be JSONify using json.dump.
+        """Return a dict that can be serialized using json.dump.
 
         Advanced usage might optionally use a callback as parameter:
 
@@ -436,7 +439,7 @@ class Model(object):
         """
         deserializer = Deserializer(cls._infer_class_models())
         deserializer.key_extractors = (  # type: ignore
-            [
+            [  # type: ignore
                 attribute_key_case_insensitive_extractor,
                 rest_key_case_insensitive_extractor,
                 last_rest_key_case_insensitive_extractor,
@@ -544,7 +547,7 @@ class Serializer(object):
         "multiple": lambda x, y: x % y != 0,
     }
 
-    def __init__(self, classes=None):
+    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
         self.serialize_type = {
             "iso-8601": Serializer.serialize_iso,
             "rfc-1123": Serializer.serialize_rfc,
@@ -560,7 +563,7 @@ class Serializer(object):
             "[]": self.serialize_iter,
             "{}": self.serialize_dict,
         }
-        self.dependencies = dict(classes) if classes else {}
+        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
         self.key_transformer = full_restapi_key_transformer
         self.client_side_validation = True
 
@@ -652,8 +655,7 @@ class Serializer(object):
                             serialized.append(local_node)  # type: ignore
                     else:  # JSON
                         for k in reversed(keys):  # type: ignore
-                            unflattened = {k: new_attr}
-                            new_attr = unflattened
+                            new_attr = {k: new_attr}
 
                         _new_attr = new_attr
                         _serialized = serialized
@@ -682,8 +684,8 @@ class Serializer(object):
         """
 
         # Just in case this is a dict
-        internal_data_type = data_type.strip("[]{}")
-        internal_data_type = self.dependencies.get(internal_data_type, None)
+        internal_data_type_str = data_type.strip("[]{}")
+        internal_data_type = self.dependencies.get(internal_data_type_str, None)
         try:
             is_xml_model_serialization = kwargs["is_xml"]
         except KeyError:
@@ -803,6 +805,8 @@ class Serializer(object):
             raise ValueError("No value for given attribute")
 
         try:
+            if data is AzureCoreNull:
+                return None
             if data_type in self.basic_types.values():
                 return self.serialize_basic(data, data_type, **kwargs)
 
@@ -1187,7 +1191,8 @@ def rest_key_extractor(attr, attr_desc, data):
     working_data = data
 
     while "." in key:
-        dict_keys = _FLATTEN.split(key)
+        # Need the cast, as for some reasons "split" is typed as list[str | Any]
+        dict_keys = cast(List[str], _FLATTEN.split(key))
         if len(dict_keys) == 1:
             key = _decode_attribute_map_key(dict_keys[0])
             break
@@ -1358,7 +1363,7 @@ class Deserializer(object):
 
     valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
 
-    def __init__(self, classes=None):
+    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
         self.deserialize_type = {
             "iso-8601": Deserializer.deserialize_iso,
             "rfc-1123": Deserializer.deserialize_rfc,
@@ -1378,7 +1383,7 @@ class Deserializer(object):
             "duration": (isodate.Duration, datetime.timedelta),
             "iso-8601": (datetime.datetime),
         }
-        self.dependencies = dict(classes) if classes else {}
+        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
         self.key_extractors = [rest_key_extractor, xml_key_extractor]
         # Additional properties only works if the "rest_key_extractor" is used to
         # extract the keys. Making it to work whatever the key extractor is too much
@@ -1497,7 +1502,7 @@ class Deserializer(object):
         Once classification has been determined, initialize object.
 
         :param str target: The target object type to deserialize to.
-        :param str/dict data: The response data to deseralize.
+        :param str/dict data: The response data to deserialize.
         """
         if target is None:
             return None, None
@@ -1512,7 +1517,7 @@ class Deserializer(object):
             target = target._classify(data, self.dependencies)
         except AttributeError:
             pass  # Target is not a Model, no classify
-        return target, target.__class__.__name__
+        return target, target.__class__.__name__  # type: ignore
 
     def failsafe_deserialize(self, target_obj, data, content_type=None):
         """Ignores any errors encountered in deserialization,
@@ -1522,7 +1527,7 @@ class Deserializer(object):
         a deserialization error.
 
         :param str target_obj: The target object type to deserialize to.
-        :param str/dict data: The response data to deseralize.
+        :param str/dict data: The response data to deserialize.
         :param str content_type: Swagger "produces" if available.
         """
         try:

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

@@ -19,14 +19,15 @@ def _format_url_section(template, **kwargs):
         try:
             return template.format(**kwargs)
         except KeyError as key:
-            formatted_components = template.split("/")
+            # Need the cast, as for some reasons "split" is typed as list[str | Any]
+            formatted_components = cast(List[str], template.split("/"))
             components = [
                 c for c in formatted_components if "{{{}}}".format(key.args[0]) not in c
             ]
             template = "/".join(components)
 {% endif %}
 {% if code_model.need_mixin_abc %}
-    {% for client in code_model.clients | selectattr("has_mixin") %}
+    {% for client in clients | selectattr("has_mixin") %}
 
 class {{ client.name }}MixinABC(ABC):
     """DO NOT use this class. It is for internal typing use only."""

package/autorest/jsonrpc/localapi.py

@@ -26,17 +26,17 @@ class LocalAutorestAPI(AutorestAPI):
             reachable_files = []
         self._reachable_files = reachable_files
         self._output_folder = Path(output_folder)
-        self.values: Dict[str, Optional[str]] = dict()
+        self.values: Dict[str, Optional[str]] = {}
 
     def write_file(self, filename: Union[str, Path], file_content: str) -> None:
         _LOGGER.debug("Writing file: %s", filename)
-        with (self._output_folder / Path(filename)).open("w") as fd:
+        with (self._output_folder / Path(filename)).open("w", encoding="utf-8") as fd:
             fd.write(file_content)
         _LOGGER.debug("Written file: %s", filename)
 
     def read_file(self, filename: Union[str, Path]) -> str:
         _LOGGER.debug("Reading file: %s", filename)
-        with (self._output_folder / Path(filename)).open("r") as fd:
+        with (self._output_folder / Path(filename)).open("r", encoding="utf-8") as fd:
             return fd.read()
 
     def list_inputs(self) -> List[str]:

package/autorest/jsonrpc/server.py

@@ -84,15 +84,15 @@ def main() -> None:
     ):
         try:
             import ptvsd  # pylint: disable=import-outside-toplevel
-        except ImportError:
+        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()
-        breakpoint()  # pylint: disable=undefined-variable
+        breakpoint()  # pylint: disable=undefined-variable,forgotten-debug-statement
 
     _LOGGER.debug("Starting JSON RPC server")
 

package/autorest/m2r/__init__.py

@@ -22,7 +22,7 @@ class AutorestRender(m2r2.RestRenderer):
     in the description/summary.
     """
 
-    def inline_html(self, html: str) -> str:  # pylint: disable=no-self-use
+    def inline_html(self, html: str) -> str:
         """Do not render inline HTML with a role definition."""
         return f":code:`{html}`"
 

package/autorest/m4reformatter/__init__.py

@@ -423,6 +423,12 @@ class M4Reformatter(
     def legacy(self) -> bool:
         return not (self.version_tolerant or self.low_level_client)
 
+    @property
+    def only_path_and_body_parameters_positional(self) -> bool:
+        return self.version_tolerant or bool(
+            self._autorestapi.get_boolean_value("only-path-and-body-params-positional")
+        )
+
     @property
     def default_optional_constants_to_none(self) -> bool:
         return bool(
@@ -952,7 +958,11 @@ class M4Reformatter(
             if name == "$host":
                 # I am the non-parameterized endpoint. Modify name based off of flag
 
-                client_name = "base_url" if self.legacy else "endpoint"
+                client_name = (
+                    "endpoint"
+                    if self.only_path_and_body_parameters_positional
+                    else "base_url"
+                )
                 global_parameter["language"]["default"]["description"] = "Service URL."
             elif (
                 global_parameter.get("origin") == "modelerfour:synthesized/api-version"
@@ -1083,7 +1093,7 @@ class M4Reformatter(
             "skipUrlEncoding": True,
             "inOverload": False,
         }
-        if self.version_tolerant or self.low_level_client:
+        if self.only_path_and_body_parameters_positional:
             parameters.append(credential)
         else:
             parameters.insert(0, credential)