@autorest/python 6.4.5 → 6.4.7

package/autorest/codegen/models/code_model.py

@@ -194,7 +194,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods
 
     @property
     def public_model_types(self) -> List[ModelType]:
-        return [m for m in self.model_types if m.is_public and not m.base == "json"]
+        return [m for m in self.model_types if not m.internal and not m.base == "json"]
 
     @property
     def enums(self) -> List[EnumType]:

package/autorest/codegen/models/model_type.py

@@ -12,13 +12,11 @@ from .constant_type import ConstantType
 from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 
-
 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 TYPE_CHECKING:
     from .code_model import CodeModel
 
@@ -74,7 +72,7 @@ class ModelType(  # pylint: disable=abstract-method
         )
         self._created_json_template_representation = False
         self._got_polymorphic_subtypes = False
-        self.is_public: bool = self.yaml_data.get("isPublic", True)
+        self.internal: bool = self.yaml_data.get("internal", False)
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
 
     @property
@@ -284,7 +282,7 @@ class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
     def type_annotation(self, **kwargs: Any) -> str:
         is_operation_file = kwargs.pop("is_operation_file", False)
         retval = f"_models.{self.name}"
-        if not self.is_public:
+        if self.internal:
             retval = f"{self.code_model.models_filename}.{retval}"
         return retval if is_operation_file else f'"{retval}"'
 
@@ -321,7 +319,7 @@ class MsrestModelType(GeneratedModelType):
     @property
     def serialization_type(self) -> str:
         private_model_path = f"_models.{self.code_model.models_filename}."
-        return f"{'' if self.is_public else private_model_path}{self.name}"
+        return f"{private_model_path if self.internal else ''}{self.name}"
 
     @property
     def instance_check_template(self) -> str:
@@ -340,7 +338,7 @@ class DPGModelType(GeneratedModelType):
 
     @property
     def serialization_type(self) -> str:
-        return f"{'' if self.is_public else '_models.'}_models.{self.name}"
+        return f"{'_models.' if self.internal else ''}_models.{self.name}"
 
     @property
     def instance_check_template(self) -> str:

package/autorest/codegen/models/operation.py

@@ -82,6 +82,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             "isLroInitialOperation", False
         )
         self.include_documentation: bool = not self.is_lro_initial_operation
+        self.internal: bool = self.yaml_data.get("internal", False)
+        if self.internal:
+            self.name = "_" + self.name
 
     @property
     def expose_stream_keyword(self) -> bool:

package/autorest/codegen/models/parameter.py

@@ -140,7 +140,11 @@ class _ParameterBase(
 
     def type_annotation(self, **kwargs: Any) -> str:
         kwargs["is_operation_file"] = True
-        type_annot = self.type.type_annotation(**kwargs)
+        # special logic for api-version parameter
+        if self.is_api_version:
+            type_annot = "str"
+        else:
+            type_annot = self.type.type_annotation(**kwargs)
         if self.optional and self.client_default_value is None:
             return f"Optional[{type_annot}]"
         return type_annot
@@ -176,9 +180,13 @@ class _ParameterBase(
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = self._imports_shared(async_mode, **kwargs)
-        file_import.merge(
-            self.type.imports(is_operation_file=True, async_mode=async_mode, **kwargs)
-        )
+        # special logic for api-version parameter
+        if not self.is_api_version:
+            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(

package/autorest/codegen/serializers/builder_serializer.py

@@ -305,7 +305,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
     def description_and_summary(self, builder: BuilderType) -> List[str]:
         description_list: List[str] = []
         description_list.append(
-            f"{ builder.summary.strip() if builder.summary else builder.description.strip() }"
+            f"{builder.summary.strip() if builder.summary else builder.description.strip()}"
         )
         if builder.summary and builder.description:
             description_list.append("")
@@ -328,7 +328,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             if not param.in_docstring:
                 continue
             description_list.extend(
-                f":{param.description_keyword} { param.client_name }: { param.description }".replace(
+                f":{param.description_keyword} {param.client_name}: {param.description}".replace(
                     "\n", "\n "
                 ).split(
                     "\n"
@@ -704,9 +704,12 @@ class _OperationSerializer(
             check_client_input=not self.code_model.options["multiapi"],
         )
         cls_annotation = builder.cls_type_annotation(async_mode=self.async_mode)
-        kwargs.append(f"cls: {cls_annotation} = kwargs.pop('cls', None)")
+        pylint_disable = ""
         if any(x.startswith("_") for x in cls_annotation.split(".")):
-            kwargs[-1] += " # pylint: disable=protected-access"
+            pylint_disable = "  # pylint: disable=protected-access"
+        kwargs.append(
+            f"cls: {cls_annotation} = kwargs.pop({pylint_disable}\n    'cls', None\n)"
+        )
         return kwargs
 
     def response_docstring(self, builder: OperationType) -> List[str]:
@@ -1047,15 +1050,23 @@ class _OperationSerializer(
                 )
             )
         elif response.type:
+            pylint_disable = ""
+            if isinstance(response.type, ModelType) and response.type.internal:
+                pylint_disable = "  # pylint: disable=protected-access"
             if self.code_model.options["models_mode"] == "msrest":
+                deserialize_code.append("deserialized = self._deserialize(")
                 deserialize_code.append(
-                    f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
+                    f"    '{response.serialization_type}',{pylint_disable}"
                 )
+                deserialize_code.append("    pipeline_response")
+                deserialize_code.append(")")
             elif self.code_model.options["models_mode"] == "dpg":
+                deserialize_code.append("deserialized = _deserialize(")
                 deserialize_code.append(
-                    f"deserialized = _deserialize({response.type.type_annotation(is_operation_file=True)}"
-                    ", response.json())"
+                    f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
                 )
+                deserialize_code.append("    response.json()")
+                deserialize_code.append(")")
             else:
                 deserialized_value = (
                     "ET.fromstring(response.text())"
@@ -1247,7 +1258,7 @@ class _OperationSerializer(
     @staticmethod
     def get_metadata_url(builder: OperationType) -> str:
         url = _escape_str(builder.request_builder.url)
-        return f"{builder.name}.metadata = {{'url': { url }}}"
+        return f"{builder.name}.metadata = {{'url': {url}}}"
 
     @property
     def _call_method(self) -> str:
@@ -1379,10 +1390,10 @@ class _PagingOperationSerializer(
         if self.code_model.options["models_mode"] == "msrest":
             deserialize_type = response.serialization_type
             pylint_disable = "  # pylint: disable=protected-access"
-            if isinstance(response.type, ModelType) and response.type.is_public:
+            if isinstance(response.type, ModelType) and not response.type.internal:
                 deserialize_type = f'"{response.serialization_type}"'
                 pylint_disable = ""
-            deserialized = f"self._deserialize(\n    {deserialize_type}, pipeline_response{pylint_disable}\n)"
+            deserialized = f"self._deserialize(\n    {deserialize_type},{pylint_disable}\n    pipeline_response\n)"
             retval.append(f"    deserialized = {deserialized}")
         elif self.code_model.options["models_mode"] == "dpg":
             # we don't want to generate paging models for DPG
@@ -1501,7 +1512,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("if cont_token is None:")
         retval.append(
             f"    raw_result = {self._call_method}self.{builder.initial_operation.name}("
-            f"{''  if builder.lro_response and builder.lro_response.type else '  # type: ignore'}"
+            f"{'' if builder.lro_response and builder.lro_response.type else '  # type: ignore'}"
         )
         retval.extend(
             [

package/autorest/codegen/serializers/model_serializer.py

@@ -215,7 +215,7 @@ class DpgModelSerializer(_ModelSerializer):
                 file_import.merge(prop.imports())
             if model.is_polymorphic:
                 file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
-            if model.is_public and self.init_line(model):
+            if not model.internal and self.init_line(model):
                 file_import.add_submodule_import(
                     "typing", "overload", ImportType.STDLIB
                 )
@@ -251,7 +251,7 @@ class DpgModelSerializer(_ModelSerializer):
         return properties_to_declare
 
     @staticmethod
-    def declare_property(prop: Property) -> List[str]:
+    def declare_property(prop: Property) -> str:
         args = []
         if prop.client_name != prop.rest_api_name or prop.is_discriminator:
             args.append(f'name="{prop.rest_api_name}"')
@@ -266,14 +266,10 @@ class DpgModelSerializer(_ModelSerializer):
             and prop.is_discriminator
             and cast(ConstantType, prop.type).value
         )
-        ret = [
+        return (
             f"{prop.client_name}: {prop.type_annotation()} ="
             f' {field}({", ".join(args)}){"  # type: ignore" if type_ignore else ""}'
-        ]
-        comment = prop.description(is_operation_file=False).replace('"', '\\"')
-        if comment:
-            ret.append(f'"""{comment}"""')
-        return ret
+        )
 
     def initialize_properties(self, model: ModelType) -> List[str]:
         init_args = []

package/autorest/codegen/serializers/parameter_serializer.py

@@ -127,6 +127,7 @@ class ParameterSerializer:
         if pop_headers_kwarg != PopKwargType.NO or pop_params_kwarg != PopKwargType.NO:
             retval.append("")
         for kwarg in parameters:
+            type_annot = kwarg.type_annotation()
             if kwarg.client_default_value is not None or kwarg.optional:
                 if check_client_input and kwarg.check_client_input:
                     default_value = f"self._config.{kwarg.client_name}"
@@ -145,11 +146,10 @@ class ParameterSerializer:
                         f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
                     )
                 retval.append(
-                    f"{kwarg.client_name}: {kwarg.type_annotation()} = kwargs.pop('{kwarg.client_name}', "
+                    f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}', "
                     + f"{default_value})"
                 )
             else:
-                type_annot = kwarg.type_annotation()
                 retval.append(
                     f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}')"
                 )

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

@@ -1,7 +1,5 @@
 {% 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 }},
@@ -52,15 +50,15 @@
                     "description": "API version to use if no profile is provided, or if missing in profile.",
                     "docstring_type": "str",
                     "required": false,
-                    "method_location": {{ method_location | tojson }}
+                    "method_location": "positional"
                 },
                 {% if not client.has_parameterized_host %}
-                "{{ "endpoint" if only_path else "base_url" }}": {
+                "base_url": {
                     "signature": {{ client.parameters.host.method_signature(async_mode=False) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false,
-                    "method_location": {{ method_location | tojson }}
+                    "method_location": "positional"
                 },
                 {% endif %}
                 "profile": {
@@ -68,7 +66,7 @@
                     "description": "A profile definition, from KnownProfiles to dict.",
                     "docstring_type": "azure.profiles.KnownProfiles",
                     "required": false,
-                    "method_location": {{ method_location | tojson }}
+                    "method_location": "positional"
                 }
             },
             "async": {
@@ -77,15 +75,15 @@
                     "description": "API version to use if no profile is provided, or if missing in profile.",
                     "docstring_type": "str",
                     "required": false,
-                    "method_location": {{ method_location | tojson }}
+                    "method_location": "positional"
                 },
                 {% if not client.has_parameterized_host %}
-                "{{ "endpoint" if only_path else "base_url" }}": {
+                "base_url": {
                     "signature": {{ client.parameters.host.method_signature(async_mode=True) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false,
-                    "method_location": {{ method_location | tojson }}
+                    "method_location": "positional"
                 },
                 {% endif %}
                 "profile": {
@@ -93,7 +91,7 @@
                     "description": "A profile definition, from KnownProfiles to dict.",
                     "docstring_type": "azure.profiles.KnownProfiles",
                     "required": false,
-                    "method_location": {{ method_location | tojson }}
+                    "method_location": "positional"
                 }
             }
         }

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

@@ -421,7 +421,10 @@ class Model(_MyMutableMapping):
             if non_attr_kwargs:
                 # actual type errors only throw the first wrong keyword arg they see, so following that.
                 raise TypeError(f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'")
-            dict_to_pass.update({self._attr_to_rest_field[k]._rest_name: _serialize(v) for k, v in kwargs.items()})
+            dict_to_pass.update({
+                self._attr_to_rest_field[k]._rest_name: _serialize(v)
+                for k, v in kwargs.items() if v is not None
+            })
         super().__init__(dict_to_pass)
 
     def copy(self) -> "Model":

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

@@ -31,12 +31,14 @@
     __mapping__: Dict[str, _model_base.Model] = {}
     {% endif %}
     {% for p in serializer.get_properties_to_declare(model)%}
-        {% for line in serializer.declare_property(p) %}
-    {{ line }}
-        {% endfor %}
+    {{ serializer.declare_property(p) }}
+        {% set prop_description = p.description(is_operation_file=False).replace('"', '\\"') %}
+        {% if prop_description %}
+    """{{ prop_description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n     ') }}"""
+        {% endif %}
     {% endfor %}
 
-    {% if model.is_public and serializer.init_line(model) %}
+    {% if not model.internal and serializer.init_line(model) %}
     @overload
     def __init__(
         self,
@@ -55,7 +57,7 @@
 
     {% endif %}
     {% set initialize_properties = serializer.initialize_properties(model) %}
-    {% if model.is_public and serializer.init_line(model) or initialize_properties %}
+    {% if not model.internal and serializer.init_line(model) or initialize_properties %}
     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 %}

package/autorest/codegen/templates/operation_tools.jinja2

@@ -62,5 +62,9 @@ _SERIALIZER.client_side_validation = False
 {% macro generate_overloads(operation_serializer, operation) %}
 {% for overload in operation.overloads %}
 {{ operation_serializer.method_signature_and_response_type_annotation(overload) }}
+{% if not operation.internal %}
     {{ description(overload, operation_serializer) | indent }}
+{% else %}
+    ...
+{% endif %}
 {% endfor %}{% endmacro %}

package/autorest/m4reformatter/__init__.py

@@ -602,7 +602,7 @@ class M4Reformatter(
         )
         if self.version_tolerant:
             # if we're in version tolerant, hide the paging model
-            returned_response_object["type"]["isPublic"] = False
+            returned_response_object["type"]["internal"] = True
         operation["itemType"] = next(
             p["type"]
             for p in returned_response_object["type"]["properties"]
@@ -994,11 +994,7 @@ class M4Reformatter(
             if name == "$host":
                 # I am the non-parameterized endpoint. Modify name based off of flag
 
-                client_name = (
-                    "endpoint"
-                    if self.only_path_and_body_parameters_positional
-                    else "base_url"
-                )
+                client_name = "endpoint" if self.version_tolerant else "base_url"
                 global_parameter["language"]["default"]["description"] = "Service URL."
             elif (
                 global_parameter.get("origin") == "modelerfour:synthesized/api-version"
@@ -1129,7 +1125,7 @@ class M4Reformatter(
             "skipUrlEncoding": True,
             "inOverload": False,
         }
-        if self.only_path_and_body_parameters_positional:
+        if self.version_tolerant:
             parameters.append(credential)
         else:
             parameters.insert(0, credential)

package/autorest/preprocess/__init__.py

@@ -218,10 +218,27 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 )
                 add_redefined_builtin_info(property["clientName"], property)
             if type.get("name"):
+                type["name"] = self.pad_reserved_words(type["name"], PadType.MODEL)
                 type["description"] = update_description(
                     type["description"], type["name"]
                 )
                 type["snakeCaseName"] = to_snake_case(type["name"])
+            if type.get("values") and not self.version_tolerant:
+                # we're enums
+                values_to_add = []
+                for value in type["values"]:
+                    padded_name = self.pad_reserved_words(
+                        value["name"].lower(), PadType.ENUM
+                    ).upper()
+                    if value["name"] != padded_name:
+                        values_to_add.append(
+                            {
+                                "description": value["description"],
+                                "name": padded_name,
+                                "value": value["value"],
+                            }
+                        )
+                type["values"].extend(values_to_add)
 
     def update_client(self, yaml_data: Dict[str, Any]) -> None:
         yaml_data["description"] = update_description(
@@ -325,14 +342,22 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         code_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
+        item_type: Optional[Dict[str, Any]] = None,
     ) -> None:
         self.update_lro_operation(code_model, yaml_data, is_overload=is_overload)
-        self.update_paging_operation(code_model, yaml_data, is_overload=is_overload)
+        self.update_paging_operation(
+            code_model, yaml_data, is_overload=is_overload, item_type=item_type
+        )
         yaml_data["discriminator"] = "lropaging"
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lropaging"
         for overload in yaml_data.get("overloads", []):
-            self.update_lro_paging_operation(code_model, overload, is_overload=True)
+            self.update_lro_paging_operation(
+                code_model,
+                overload,
+                is_overload=True,
+                item_type=yaml_data["responses"][0]["itemType"],
+            )
 
     def update_lro_operation(
         self,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.4.5",
+  "version": "6.4.7",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {
@@ -22,7 +22,7 @@
     "@autorest/system-requirements": "~1.0.0"
   },
   "devDependencies": {
-    "@microsoft.azure/autorest.testserver": "^3.3.45",
+    "@microsoft.azure/autorest.testserver": "^3.3.46",
     "typescript": "^4.8.3"
   },
   "files": [

package/requirements.txt

@@ -6,7 +6,7 @@ json-rpc==1.14.0
 m2r2==0.3.3
 MarkupSafe==2.1.2
 mistune==0.8.4
-pathspec==0.11.0
-platformdirs==3.1.0
+pathspec==0.11.1
+platformdirs==3.2.0
 PyYAML==6.0
 tomli==2.0.1