@autorest/python 6.4.6 → 6.4.8

package/autorest/codegen/__init__.py

@@ -16,6 +16,10 @@ from .serializers import JinjaSerializer, JinjaSerializerAutorest
 from ._utils import DEFAULT_HEADER_TEXT
 
 
+def _default_pprint(package_name: str) -> str:
+    return " ".join([i.capitalize() for i in package_name.split("-")])
+
+
 def _validate_code_model_options(options: Dict[str, Any]) -> None:
     if options["builders_visibility"] not in ["public", "hidden", "embedded"]:
         raise ValueError(
@@ -126,6 +130,7 @@ class CodeGenerator(Plugin):
         if self.options.get("cadl_file") is not None:
             models_mode_default = "dpg"
 
+        package_name = self.options.get("package-name")
         options: Dict[str, Any] = {
             "azure_arm": azure_arm,
             "head_as_boolean": self.options.get("head-as-boolean", True),
@@ -134,7 +139,7 @@ class CodeGenerator(Plugin):
             "no_async": self.options.get("no-async", False),
             "no_namespace_folders": self.options.get("no-namespace-folders", False),
             "basic_setup_py": self.options.get("basic-setup-py", False),
-            "package_name": self.options.get("package-name"),
+            "package_name": package_name,
             "package_version": self.options.get("package-version"),
             "client_side_validation": self.options.get("client-side-validation", False),
             "tracing": self.options.get("tracing", show_operations),
@@ -156,7 +161,8 @@ class CodeGenerator(Plugin):
                 "combine-operation-files", version_tolerant
             ),
             "package_mode": self.options.get("package-mode"),
-            "package_pprint_name": self.options.get("package-pprint-name"),
+            "package_pprint_name": self.options.get("package-pprint-name")
+            or _default_pprint(str(package_name)),
             "package_configuration": self.options.get("package-configuration"),
             "default_optional_constants_to_none": self.options.get(
                 "default-optional-constants-to-none",

package/autorest/codegen/models/client.py

@@ -146,6 +146,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         retval = add_to_pylint_disable("", "client-accepts-api-version-keyword")
         if len(self.operation_groups) > 6:
             retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
+        if len(self.name) > 40:
+            retval = add_to_pylint_disable(retval, "name-too-long")
         return retval
 
     @property

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:
@@ -127,6 +130,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.response_type_annotation(async_mode=False) == "None":
             # doesn't matter if it's async or not
             retval = add_to_pylint_disable(retval, "inconsistent-return-statements")
+        if len(self.name) > 40:
+            retval = add_to_pylint_disable(retval, "name-too-long")
         return retval
 
     def cls_type_annotation(self, *, async_mode: bool) -> str:

package/autorest/codegen/models/request_builder.py

@@ -16,6 +16,7 @@ from typing import (
 from abc import abstractmethod
 
 from .base_builder import BaseBuilder
+from .utils import add_to_pylint_disable
 from .parameter_list import (
     RequestBuilderParameterList,
     OverloadedRequestBuilderParameterList,
@@ -56,6 +57,12 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         self.method: str = yaml_data["method"]
         self.want_tracing = False
 
+    @property
+    def pylint_disable(self) -> str:
+        if len(self.name) > 40:
+            return add_to_pylint_disable("", "name-too-long")
+        return ""
+
     def response_type_annotation(self, **kwargs) -> str:
         return "HttpRequest"
 

package/autorest/codegen/serializers/builder_serializer.py

@@ -58,6 +58,14 @@ OperationType = TypeVar(
 )
 
 
+def _xml_config(send_xml: bool, content_types: List[str]) -> str:
+    if not (send_xml and "xml" in str(content_types)):
+        return ""
+    if len(content_types) == 1:
+        return ", is_xml=True"
+    return ", is_xml='xml' in str(content_type)"
+
+
 def _escape_str(input_str: str) -> str:
     replace = input_str.replace("'", "\\'")
     return f'"{replace}"'
@@ -305,7 +313,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 +336,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 +712,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]:
@@ -738,7 +749,9 @@ class _OperationSerializer(
         if xml_serialization_ctxt and self.code_model.options["models_mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{xml_serialization_ctxt}}}}}')
         if self.code_model.options["models_mode"] == "msrest":
-            is_xml_cmd = ", is_xml=True" if send_xml else ""
+            is_xml_cmd = _xml_config(
+                send_xml, builder.parameters.body_parameter.content_types
+            )
             serialization_ctxt_cmd = (
                 f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
             )
@@ -1047,15 +1060,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 +1268,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 +1400,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 +1522,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/codegen/templates/packaging_templates/setup.py.jinja2

@@ -24,12 +24,12 @@ with open(os.path.join(package_folder_path, "_version.py"), "r") as fd:
 
 if not version:
     raise RuntimeError("Cannot find version information")
-{% set description = "Microsoft %s Client Library for Python"|format(package_pprint_name) %}
+{% set description = "\"Microsoft {} Client Library for Python\".format(PACKAGE_PPRINT_NAME)" %}
 {% set author_email = "azpysdkhelp@microsoft.com" %}
 {% set url = "https://github.com/Azure/azure-sdk-for-python/tree/main/sdk" %}
 {% else %}
 version = "{{ package_version }}"
-{% set description = "%s"|format(package_name) %}
+{% set description = "\"%s\""|format(package_name) %}
 {% set long_description = code_model.description %}
 {% set author_email = "" %}
 {% set url = "" %}
@@ -38,7 +38,7 @@ version = "{{ package_version }}"
 setup(
     name=PACKAGE_NAME,
     version=version,
-    description="{{ description }}",
+    description={{ description }},
     {% if package_mode %}
     long_description=open("README.md", "r").read(),
     long_description_content_type="text/markdown",

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.8",
   "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": [