@autorest/python 6.2.16 → 6.3.1

package/README.md

@@ -215,5 +215,5 @@ help-content:
 
 <!-- LINKS -->
 
-[python_docs]: https://github.com/Azure/autorest.python/tree/autorestv3/docs/readme.md
+[python_docs]: https://github.com/Azure/autorest.python/tree/main/docs/readme.md
 [main_docs]: https://github.com/Azure/autorest/tree/master/docs

package/autorest/codegen/models/__init__.py

@@ -6,7 +6,7 @@
 import logging
 from typing import Any, Dict, Union
 from .base import BaseModel
-from .base_builder import BaseBuilder
+from .base_builder import BaseBuilder, ParameterListType
 from .code_model import CodeModel
 from .client import Client
 from .model_type import ModelType, JSONModelType, DPGModelType, MsrestModelType
@@ -116,6 +116,7 @@ __all__ = [
     "CredentialType",
     "ClientParameter",
     "ConfigParameter",
+    "ParameterListType",
 ]
 
 TYPE_TO_OBJECT = {

package/autorest/codegen/models/base.py

@@ -186,4 +186,4 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
 
     @property
     def type_description(self) -> str:
-        return self.type  # type: ignore
+        return self.type_annotation()

package/autorest/codegen/models/base_builder.py

@@ -63,6 +63,7 @@ class BaseBuilder(
         self.is_overload: bool = yaml_data["isOverload"]
         self.api_versions: List[str] = yaml_data["apiVersions"]
         self.added_on: Optional[str] = yaml_data.get("addedOn")
+        self.external_docs: Optional[Dict[str, Any]] = yaml_data.get("externalDocs")
 
         if code_model.options["version_tolerant"] and yaml_data.get("abstract"):
             _LOGGER.warning(

package/autorest/codegen/models/combined_type.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Optional, TYPE_CHECKING
 import re
 from autorest.codegen.models.imports import FileImport, ImportType
 from .base import BaseType
+from .model_type import JSONModelType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -111,3 +112,20 @@ class CombinedType(BaseType):
             code_model,
             [build_type(t, code_model) for t in yaml_data["types"]],
         )
+
+    @staticmethod
+    def _get_json_model_type(t: BaseType) -> Optional[JSONModelType]:
+        if isinstance(t, JSONModelType):
+            return t
+        if isinstance(t, CombinedType):
+            try:
+                return next(
+                    CombinedType._get_json_model_type(sub_t) for sub_t in t.types
+                )
+            except StopIteration:
+                pass
+        return None
+
+    @property
+    def json_subtype(self) -> Optional[JSONModelType]:
+        return CombinedType._get_json_model_type(self)

package/autorest/codegen/models/credential_types.py

@@ -162,6 +162,10 @@ class TokenCredentialType(
             return '"AsyncTokenCredential"'
         return '"TokenCredential"'
 
+    @property
+    def type_description(self) -> str:
+        return "TokenCredential"
+
     def docstring_type(self, **kwargs: Any) -> str:
         if kwargs.get("async_mode"):
             return "~azure.core.credentials_async.AsyncTokenCredential"

package/autorest/codegen/models/dictionary_type.py

@@ -129,3 +129,7 @@ class DictionaryType(BaseType):
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, dict)"
+
+    @property
+    def type_description(self) -> str:
+        return f"{{str: {self.element_type.type_description}}}"

package/autorest/codegen/models/list_type.py

@@ -153,3 +153,7 @@ class ListType(BaseType):
             )
         file_import.merge(self.element_type.imports(**kwargs))
         return file_import
+
+    @property
+    def type_description(self) -> str:
+        return f"[{self.element_type.type_description}]"

package/autorest/codegen/models/model_type.py

@@ -295,6 +295,10 @@ class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
     def docstring_text(self, **kwargs: Any) -> str:
         return self.name
 
+    @property
+    def type_description(self) -> str:
+        return self.name
+
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
         relative_path = kwargs.pop("relative_path", None)

package/autorest/codegen/models/parameter.py

@@ -86,6 +86,10 @@ class _ParameterBase(
         self.check_client_input: bool = self.yaml_data.get("checkClientInput", False)
         self.added_on: Optional[str] = self.yaml_data.get("addedOn")
         self.is_api_version: bool = self.yaml_data.get("isApiVersion", False)
+        self.in_overload: bool = self.yaml_data.get("inOverload", False)
+        self.default_to_unset_sentinel: bool = self.yaml_data.get(
+            "defaultToUnsetSentinel", False
+        )
 
     @property
     def constant(self) -> bool:
@@ -168,6 +172,12 @@ class _ParameterBase(
         file_import.merge(
             self.type.imports(is_operation_file=True, async_mode=async_mode, **kwargs)
         )
+        if self.default_to_unset_sentinel:
+            file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
+            file_import.define_mypy_type(
+                "_Unset: Any",
+                "object()",
+            )
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
@@ -208,11 +218,13 @@ class _ParameterBase(
         type_annot = self.type_annotation(async_mode=async_mode)
         if self.client_default_value is not None or self.optional:
             return f"{self.client_name}: {type_annot} = {self.client_default_value_declaration},"
+        if self.default_to_unset_sentinel:
+            return f"{self.client_name}: {type_annot} = _Unset,"
         return f"{self.client_name}: {type_annot},"
 
 
-class _BodyParameterBase(_ParameterBase):
-    """Base class for body parameters"""
+class BodyParameter(_ParameterBase):
+    """Body parameter."""
 
     @property
     def is_partial_body(self) -> bool:
@@ -231,10 +243,6 @@ class _BodyParameterBase(_ParameterBase):
     def in_method_signature(self) -> bool:
         return not (self.flattened or self.grouped_by)
 
-
-class BodyParameter(_BodyParameterBase):
-    """Body parameter."""
-
     @property
     def content_types(self) -> List[str]:
         return self.yaml_data["contentTypes"]
@@ -243,19 +251,11 @@ class BodyParameter(_BodyParameterBase):
     def default_content_type(self) -> str:
         return self.yaml_data["defaultContentType"]
 
-    @staticmethod
-    def _has_json_model_type(t: BaseType) -> bool:
-        if isinstance(t, JSONModelType):
-            return True
-        if isinstance(t, CombinedType):
-            for sub_t in t.types:
-                if BodyParameter._has_json_model_type(sub_t):
-                    return True
-        return False
-
     @property
     def has_json_model_type(self) -> bool:
-        return BodyParameter._has_json_model_type(self.type)
+        if isinstance(self.type, CombinedType):
+            return self.type.json_subtype is not None
+        return isinstance(self.type, JSONModelType)
 
     @classmethod
     def from_yaml(
@@ -327,10 +327,9 @@ class Parameter(_ParameterBase):
         self.implementation: str = yaml_data["implementation"]
         self.skip_url_encoding: bool = self.yaml_data.get("skipUrlEncoding", False)
         self.explode: bool = self.yaml_data.get("explode", False)
-        self.in_overload: bool = self.yaml_data["inOverload"]
         self.in_overriden: bool = self.yaml_data.get("inOverriden", False)
         self.delimiter: Optional[ParameterDelimeter] = self.yaml_data.get("delimiter")
-        self.in_flattened_body: bool = self.yaml_data.get("inFlattenedBody", False)
+        self._default_to_unset_sentinel: bool = False
 
     @property
     def in_method_signature(self) -> bool:

package/autorest/codegen/serializers/builder_serializer.py

@@ -31,10 +31,11 @@ from ..models import (
     MultipartBodyParameter,
     Property,
     RequestBuilderType,
-    JSONModelType,
     CombinedType,
+    ParameterListType,
 )
 from .parameter_serializer import ParameterSerializer, PopKwargType
+from ..models.parameter_list import ParameterType
 from . import utils
 
 T = TypeVar("T")
@@ -148,22 +149,39 @@ def _serialize_flattened_body(body_parameter: BodyParameter) -> List[str]:
     return retval
 
 
-def _serialize_json_model_body(body_parameter: BodyParameter) -> List[str]:
+def _serialize_json_model_body(
+    body_parameter: BodyParameter, parameters: List[ParameterType]
+) -> List[str]:
     retval: List[str] = []
     if not body_parameter.property_to_parameter_name:
         raise ValueError(
             "This method can't be called if the operation doesn't need parameter flattening"
         )
 
-    retval.append(f"if {body_parameter.client_name} is None:")
+    retval.append(f"if {body_parameter.client_name} is _Unset:")
+    for p in parameters:
+        if (
+            p.client_default_value is None
+            and not p.optional
+            and p.default_to_unset_sentinel
+        ):
+            retval.append(f"    if {p.client_name} is _Unset:")
+            retval.append(
+                f"            raise TypeError('missing required argument: {p.client_name}')"
+            )
     parameter_string = ", \n".join(
         f'"{property_name}": {parameter_name}'
         for property_name, parameter_name in body_parameter.property_to_parameter_name.items()
     )
     model_type = cast(ModelType, body_parameter.type)
-    if isinstance(model_type, CombinedType):
-        model_type = next(t for t in model_type.types if isinstance(t, JSONModelType))
+    if isinstance(model_type, CombinedType) and model_type.json_subtype:
+        model_type = model_type.json_subtype
     retval.append(f"    {body_parameter.client_name} = {{{parameter_string}}}")
+    retval.append(f"    {body_parameter.client_name} =  {{")
+    retval.append(
+        f"        k: v for k, v in {body_parameter.client_name}.items() if v is not None"
+    )
+    retval.append("    }")
     return retval
 
 
@@ -209,6 +227,14 @@ def _api_version_validation(builder: OperationType) -> str:
     return ""
 
 
+def is_json_model_type(parameters: ParameterListType) -> bool:
+    return (
+        parameters.has_body
+        and parameters.body_parameter.has_json_model_type
+        and any(p.in_flattened_body for p in parameters.parameters)
+    )
+
+
 class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         self.code_model = code_model
@@ -334,12 +360,11 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         ):
             # No input template if now body parameter
             return template
-        if builder.overloads:
-            # if there's overloads, we do the json input example template on the overload
-            return template
 
         body_param = builder.parameters.body_parameter
-        if not isinstance(body_param.type, (ListType, DictionaryType, ModelType)):
+        if not isinstance(
+            body_param.type, (ListType, DictionaryType, ModelType, CombinedType)
+        ):
             return template
 
         if (
@@ -351,8 +376,14 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         if isinstance(body_param.type, ModelType) and body_param.type.base != "json":
             return template
 
+        json_type = body_param.type
+        if isinstance(body_param.type, CombinedType):
+            if body_param.type.json_subtype is None:
+                return template
+            json_type = body_param.type.json_subtype
+
         polymorphic_subtypes: List[ModelType] = []
-        body_param.type.get_polymorphic_subtypes(polymorphic_subtypes)
+        json_type.get_polymorphic_subtypes(polymorphic_subtypes)
         if polymorphic_subtypes:
             # we just assume one kind of polymorphic body for input
             discriminator_name = cast(
@@ -376,7 +407,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             "# JSON input template you can fill out and use as your body input."
         )
         json_template = _json_dumps_template(
-            body_param.type.get_json_template_representation(),
+            json_type.get_json_template_representation(),
         )
         template.extend(
             f"{builder.parameters.body_parameter.client_name} = {json_template}".splitlines()
@@ -552,6 +583,10 @@ class _OperationSerializer(
             retval.append(".. warning::")
             retval.append("    This method is deprecated")
             retval.append("")
+        if builder.external_docs and builder.external_docs.get("url"):
+            retval.append(".. seealso::")
+            retval.append(f"   - {builder.external_docs['url']}")
+            retval.append("")
         return retval
 
     @property
@@ -949,12 +984,12 @@ class _OperationSerializer(
         if builder.parameters.has_body and builder.parameters.body_parameter.flattened:
             # unflatten before passing to request builder as well
             retval.extend(_serialize_flattened_body(builder.parameters.body_parameter))
-        if (
-            builder.parameters.has_body
-            and builder.parameters.body_parameter.has_json_model_type
-            and any(p.in_flattened_body for p in builder.parameters.parameters)
-        ):
-            retval.extend(_serialize_json_model_body(builder.parameters.body_parameter))
+        if is_json_model_type(builder.parameters):
+            retval.extend(
+                _serialize_json_model_body(
+                    builder.parameters.body_parameter, builder.parameters.parameters
+                )
+            )
         if builder.overloads:
             # we are only dealing with two overloads. If there are three, we generate an abstract operation
             retval.extend(self._initialize_overloads(builder, is_paging=is_paging))

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -16,7 +16,10 @@ from ..models import (
     Client,
 )
 from .import_serializer import FileImportSerializer
-from .builder_serializer import get_operation_serializer, RequestBuilderSerializer
+from .builder_serializer import (
+    get_operation_serializer,
+    RequestBuilderSerializer,
+)
 
 
 class OperationGroupsSerializer:

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

@@ -33,5 +33,5 @@
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}enter__()
         return self
 
-    {{ keywords.def }} __{{ keywords.async_prefix }}exit__(self, *exc_details) -> None:
+    {{ keywords.def }} __{{ keywords.async_prefix }}exit__(self, *exc_details: Any) -> None:
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}exit__(*exc_details)

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

@@ -14,7 +14,6 @@ import base64
 import re
 import copy
 import typing
-from collections.abc import MutableMapping
 from datetime import datetime, date, time, timedelta, timezone
 from json import JSONEncoder
 import isodate
@@ -23,6 +22,11 @@ from azure.core import CaseInsensitiveEnumMeta
 from azure.core.pipeline import PipelineResponse
 from azure.core.serialization import NULL as AzureCoreNull
 
+if sys.version_info >= (3, 9):
+    from collections.abc import MutableMapping
+else:
+    from typing import MutableMapping
+
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = ["NULL", "AzureJSONEncoder", "Model", "rest_field", "rest_discriminator"]
@@ -276,7 +280,7 @@ def _get_model(module_name: str, model_name: str):
 _UNSET = object()
 
 
-class _MyMutableMapping(MutableMapping):
+class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=unsubscriptable-object
     def __init__(self, data: typing.Dict[str, typing.Any]) -> None:
         self._data = copy.deepcopy(data)
 
@@ -301,13 +305,13 @@ class _MyMutableMapping(MutableMapping):
     def __ne__(self, other: typing.Any) -> bool:
         return not self.__eq__(other)
 
-    def keys(self) -> typing.KeysView:
+    def keys(self) -> typing.KeysView[str]:
         return self._data.keys()
 
-    def values(self) -> typing.ValuesView:
+    def values(self) -> typing.ValuesView[typing.Any]:
         return self._data.values()
 
-    def items(self) -> typing.ItemsView:
+    def items(self) -> typing.ItemsView[str, typing.Any]:
         return self._data.items()
 
     def get(self, key: str, default: typing.Any = None) -> typing.Any:
@@ -399,7 +403,7 @@ def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typin
 class Model(_MyMutableMapping):
     _is_model = True
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         class_name = self.__class__.__name__
         if len(args) > 1:
             raise TypeError(f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given")
@@ -420,10 +424,10 @@ class Model(_MyMutableMapping):
             dict_to_pass.update({self._attr_to_rest_field[k]._rest_name: _serialize(v) for k, v in kwargs.items()})
         super().__init__(dict_to_pass)
 
-    def copy(self):
+    def copy(self) -> "Model":
         return Model(self.__dict__)
 
-    def __new__(cls, *args: typing.Any, **kwargs: typing.Any):  # pylint: disable=unused-argument
+    def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "Model":  # 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
@@ -443,12 +447,12 @@ class Model(_MyMutableMapping):
                 rf._rest_name_input = attr
         cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items())
 
-        return super().__new__(cls)
+        return super().__new__(cls)  # pylint: disable=no-value-for-parameter
 
-    def __init_subclass__(cls, discriminator=None):
+    def __init_subclass__(cls, discriminator: typing.Optional[str] = None) -> None:
         for base in cls.__bases__:
             if hasattr(base, "__mapping__"):  # pylint: disable=no-member
-                base.__mapping__[discriminator or cls.__name__] = cls  # pylint: disable=no-member
+                base.__mapping__[discriminator or cls.__name__] = cls  # type: ignore  # pylint: disable=no-member
 
     @classmethod
     def _get_discriminator(cls) -> typing.Optional[str]:

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

@@ -56,7 +56,7 @@
     {% endif %}
     {% 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 '' }}
+    def __init__(self, *args: Any, **kwargs: Any) -> None:{{ '# pylint: disable=useless-super-delegation' if not initialize_properties else '' }}
         super().__init__(*args, **kwargs)
     {% for initialize_property in initialize_properties %}
         {{ initialize_property }}

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

@@ -5,7 +5,7 @@
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 {{ imports }}
-
+{{ unset }}
 {% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
 {{ op_tools.declare_serializer(code_model) }}
     {% for operation_group in operation_groups %}

package/autorest/m4reformatter/__init__.py

@@ -546,6 +546,7 @@ class M4Reformatter(
             "isOverload": is_overload,
             "apiVersions": _get_api_versions(yaml_data.get("apiVersions", [])),
             "abstract": abstract,
+            "externalDocs": yaml_data.get("externalDocs"),
         }
 
     def get_operation_creator(

package/autorest/preprocess/__init__.py

@@ -66,7 +66,7 @@ def add_overload(
     overload = copy.deepcopy(yaml_data)
     overload["isOverload"] = True
     overload["bodyParameter"]["type"] = body_type
-
+    overload["bodyParameter"]["defaultToUnsetSentinel"] = False
     overload["overloads"] = []
 
     if for_flatten_params:
@@ -95,6 +95,10 @@ def add_overload(
     if body_type["type"] == "binary" and len(content_types) > 1:
         content_types = "'" + "', '".join(content_types) + "'"
         content_type_param["description"] += f" Known values are: {content_types}."
+    overload["bodyParameter"]["inOverload"] = True
+    for parameter in overload["parameters"]:
+        parameter["inOverload"] = True
+        parameter["defaultToUnsetSentinel"] = False
     return overload
 
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@autorest/python",
-  "version": "6.2.16",
+  "version": "6.3.1",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Azure/autorest.python/tree/autorestv3"
+    "url": "https://github.com/Azure/autorest.python/tree/main"
   },
-  "readme": "https://github.com/Azure/autorest.python/blob/autorestv3/README.md",
+  "readme": "https://github.com/Azure/autorest.python/blob/main/README.md",
   "keywords": [
     "autorest",
     "python"
@@ -17,7 +17,7 @@
   "bugs": {
     "url": "https://github.com/Azure/autorest.python/issues"
   },
-  "homepage": "https://github.com/Azure/autorest.python/blob/autorestv3/README.md",
+  "homepage": "https://github.com/Azure/autorest.python/blob/main/README.md",
   "dependencies": {
     "@autorest/system-requirements": "~1.0.0"
   },

package/requirements.txt

@@ -4,7 +4,7 @@ docutils==0.19
 Jinja2==3.1.2
 json-rpc==1.14.0
 m2r2==0.3.3
-MarkupSafe==2.1.1
+MarkupSafe==2.1.2
 mistune==0.8.4
 mypy-extensions==0.4.3
 pathspec==0.10.3