@autorest/python 6.2.15 → 6.3.0

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

@@ -21,6 +21,7 @@ import isodate
 from azure.core.exceptions import DeserializationError
 from azure.core import CaseInsensitiveEnumMeta
 from azure.core.pipeline import PipelineResponse
+from azure.core.serialization import NULL as AzureCoreNull
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -157,6 +158,8 @@ class AzureJSONEncoder(JSONEncoder):
             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:
@@ -263,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]
@@ -465,13 +469,15 @@ class Model(_MyMutableMapping):
 
 
 def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-return-statements, too-many-statements
-        annotation: typing.Any, module: typing.Optional[str],
+        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 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
@@ -510,7 +516,7 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
             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):
@@ -533,8 +539,8 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
 
         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],
@@ -568,10 +574,10 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
                         )
 
                     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],
@@ -673,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/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/codegen/templates/serialization.py.jinja2

@@ -64,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")
 
@@ -804,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)
 

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,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.2.15",
+  "version": "6.3.0",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {

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