@autorest/python 6.4.6 → 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/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/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"]

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(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.4.6",
+  "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": [