@autorest/python 6.2.11 → 6.2.15

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

@@ -1,5 +1,7 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {% import 'keywords.jinja2' as keywords %}
+{% set only_path = client.code_model.options["only_path_and_body_params_positional"] %}
+{% set method_location = "keywordOnly" if only_path else "positional" %}
 {
     "chosen_version": {{ chosen_version | tojson }},
     "total_api_version_list": {{ total_api_version_list | tojson }},
@@ -22,7 +24,8 @@
                 "signature": {{ gp.method_signature(async_mode=False) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type(async_mode=False) | tojson }},
-                "required": {{ (not gp.optional) | tojson }}
+                "required": {{ (not gp.optional) | tojson }},
+                "method_location": {{ gp.method_location | tojson }}
             }{{ "," if not loop.last else "" }}
             {% endfor %}
         },
@@ -48,21 +51,24 @@
                     "signature": "api_version: Optional[str]=None,",
                     "description": "API version to use if no profile is provided, or if missing in profile.",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% if not client.has_parameterized_host %}
-                "base_url": {
+                "{{ "endpoint" if only_path else "base_url" }}": {
                     "signature": {{ client.parameters.host.method_signature(async_mode=False) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% endif %}
                 "profile": {
                     "signature": "profile: KnownProfiles=KnownProfiles.default,",
                     "description": "A profile definition, from KnownProfiles to dict.",
                     "docstring_type": "azure.profiles.KnownProfiles",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 }
             },
             "async": {
@@ -70,21 +76,24 @@
                     "signature": "api_version: Optional[str] = None,",
                     "description": "API version to use if no profile is provided, or if missing in profile.",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% if not client.has_parameterized_host %}
-                "base_url": {
+                "{{ "endpoint" if only_path else "base_url" }}": {
                     "signature": {{ client.parameters.host.method_signature(async_mode=True) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 },
                 {% endif %}
                 "profile": {
                     "signature": "profile: KnownProfiles = KnownProfiles.default,",
                     "description": "A profile definition, from KnownProfiles to dict.",
                     "docstring_type": "azure.profiles.KnownProfiles",
-                    "required": false
+                    "required": false,
+                    "method_location": {{ method_location | tojson }}
                 }
             }
         }

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

@@ -4,22 +4,23 @@
 # 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
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,11 +42,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 +99,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 +124,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 +143,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,7 +153,7 @@ 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()
@@ -174,7 +176,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 +184,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 +215,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 +229,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
@@ -271,7 +276,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 +312,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 +334,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 +342,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 +388,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 +419,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 +428,50 @@ 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],
     ) -> 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)):
                 def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj):
                     if _is_model(obj):
                         return obj
@@ -478,21 +483,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:
@@ -510,11 +519,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:
@@ -596,6 +605,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 +614,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)

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

@@ -4,9 +4,9 @@
 
 {{ imports }}
 {% for model in code_model.model_types %}
-{% if code_model.options["models_mode"] == "dpg" %}
+{% if model.base == "dpg" %}
 {% include "model_dpg.py.jinja2" %}
-{% else %}
+{% elif model.base == "msrest" %}
 {% include "model_msrest.py.jinja2" %}
 {% endif %}
 {% endfor %}

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/model_msrest.py.jinja2

@@ -65,8 +65,8 @@
         {% for param_signature in serializer.init_line(model) %}
         {{ param_signature }}
         {% endfor %}
-        **kwargs
-    ):
+        **kwargs: Any
+    ) -> None:
         """
     {% if model.properties %}
         {% for p in model.properties %}