@autorest/python 5.19.0 → 6.0.0-rc.1

package/autorest/codegen/serializers/{model_base_serializer.py → model_serializer.py}

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from abc import abstractmethod
 from typing import cast, List
 from jinja2 import Environment
 from ..models import ModelType, CodeModel, Property
@@ -27,22 +26,17 @@ def _documentation_string(
     return retval
 
 
-class ModelBaseSerializer:
-    def __init__(
-        self, code_model: CodeModel, env: Environment, is_python3_file: bool
-    ) -> None:
+class ModelSerializer:
+    def __init__(self, code_model: CodeModel, env: Environment) -> None:
         self.code_model = code_model
         self.env = env
-        self.is_python3_file = is_python3_file
 
     def serialize(self) -> str:
         # Generate the models
         template = self.env.get_template("model_container.py.jinja2")
         return template.render(
             code_model=self.code_model,
-            imports=FileImportSerializer(
-                self.imports(), is_python3_file=self.is_python3_file
-            ),
+            imports=FileImportSerializer(self.imports()),
             str=str,
             serializer=self,
         )
@@ -54,6 +48,11 @@ class ModelBaseSerializer:
         )
         for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
+            init_line_parameters = [
+                p for p in model.properties if not p.readonly and not p.is_discriminator
+            ]
+            for param in init_line_parameters:
+                file_import.merge(param.imports())
         return file_import
 
     @staticmethod
@@ -92,18 +91,12 @@ class ModelBaseSerializer:
     def variable_documentation_string(prop: Property) -> List[str]:
         return _documentation_string(prop, "ivar", "vartype")
 
-    @abstractmethod
-    def super_call_template(self, model: ModelType) -> str:
-        ...
-
     def super_call(self, model: ModelType):
-        return self.super_call_template(model).format(
-            self.properties_to_pass_to_super(model)
-        )
+        return f"super().__init__({self.properties_to_pass_to_super(model)})"
 
     def initialize_properties(self, model: ModelType) -> List[str]:
         init_args = []
-        for prop in ModelBaseSerializer.get_properties_to_initialize(model):
+        for prop in self.get_properties_to_initialize(model):
             if prop.is_discriminator:
                 discriminator_value = (
                     f"'{model.discriminator_value}'"
@@ -120,13 +113,17 @@ class ModelBaseSerializer:
             elif prop.readonly:
                 init_args.append(f"self.{prop.client_name} = None")
             elif not prop.constant:
-                init_args.append(self.initialize_standard_arg(prop))
+                init_args.append(f"self.{prop.client_name} = {prop.client_name}")
         return init_args
 
-    def initialize_standard_property(self, prop: Property):
+    @staticmethod
+    def initialize_standard_property(prop: Property):
         if not (prop.optional or prop.client_default_value is not None):
-            return self.required_property_no_default_init(prop)
-        return self.optional_property_init(prop)
+            return f"{prop.client_name}: {prop.type_annotation()},{prop.pylint_disable}"
+        return (
+            f"{prop.client_name}: {prop.type_annotation()} = "
+            f"{prop.client_default_value_declaration},{prop.pylint_disable}"
+        )
 
     @staticmethod
     def discriminator_docstring(model: ModelType) -> str:
@@ -135,22 +132,34 @@ class ModelBaseSerializer:
             f"Known sub-classes are: {', '.join(v.name for v in model.discriminated_subtypes.values())}"
         )
 
-    @abstractmethod
     def init_line(self, model: ModelType) -> List[str]:
-        ...
+        init_properties_declaration = []
+        init_line_parameters = [
+            p
+            for p in model.properties
+            if not p.readonly and not p.is_discriminator and not p.constant
+        ]
+        init_line_parameters.sort(key=lambda x: x.optional)
+        if init_line_parameters:
+            init_properties_declaration.append("*,")
+        for param in init_line_parameters:
+            init_properties_declaration.append(self.initialize_standard_property(param))
+
+        return init_properties_declaration
 
-    @abstractmethod
-    def properties_to_pass_to_super(self, model: ModelType) -> str:
-        ...
-
-    @abstractmethod
-    def required_property_no_default_init(self, prop: Property) -> str:
-        ...
-
-    @abstractmethod
-    def optional_property_init(self, prop: Property) -> str:
-        ...
-
-    @abstractmethod
-    def initialize_standard_arg(self, prop: Property) -> str:
-        ...
+    @staticmethod
+    def properties_to_pass_to_super(model: ModelType) -> str:
+        properties_to_pass_to_super = []
+        for parent in model.parents:
+            for prop in model.properties:
+                if (
+                    prop in parent.properties
+                    and not prop.is_discriminator
+                    and not prop.constant
+                    and not prop.readonly
+                ):
+                    properties_to_pass_to_super.append(
+                        f"{prop.client_name}={prop.client_name}"
+                    )
+        properties_to_pass_to_super.append("**kwargs")
+        return ", ".join(properties_to_pass_to_super)

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -22,13 +22,11 @@ class OperationGroupsSerializer:
         code_model: CodeModel,
         env: Environment,
         async_mode: bool,
-        is_python3_file: bool,
         operation_group: Optional[OperationGroup] = None,
     ) -> None:
         self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.operation_group = operation_group
 
     def serialize(self) -> str:
@@ -42,7 +40,6 @@ class OperationGroupsSerializer:
             imports.merge(
                 operation_group.imports(
                     async_mode=self.async_mode,
-                    is_python3_file=self.is_python3_file,
                 )
             )
 
@@ -54,21 +51,17 @@ class OperationGroupsSerializer:
             operation_groups=operation_groups,
             imports=FileImportSerializer(
                 imports,
-                is_python3_file=self.is_python3_file,
                 async_mode=self.async_mode,
             ),
             async_mode=self.async_mode,
-            is_python3_file=self.is_python3_file,
             get_operation_serializer=functools.partial(
                 get_operation_serializer,
                 code_model=self.code_model,
                 async_mode=self.async_mode,
-                is_python3_file=self.is_python3_file,
             ),
             request_builder_serializer=RequestBuilderSerializer(
                 self.code_model,
                 async_mode=False,
-                is_python3_file=self.is_python3_file,
             ),
             request_builders=[
                 rb for rb in self.code_model.request_builders if not rb.abstract

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -18,40 +18,19 @@ class OperationsInitSerializer:
         self.env = env
         self.async_mode = async_mode
 
-    def _operation_group_imports_helper(self, filename_suffix: str = "") -> List[str]:
+    def operation_group_imports(self) -> List[str]:
         def _get_filename(operation_group: OperationGroup) -> str:
-            prefix = (
+            return (
                 "_operations"
                 if self.code_model.options["combine_operation_files"]
                 else operation_group.filename
             )
-            return prefix + filename_suffix
 
         return [
             f"from .{_get_filename(og)} import {og.class_name}"
             for og in self.code_model.operation_groups
         ]
 
-    def operation_group_imports(self) -> List[str]:
-        typed_py3_files = self.code_model.options["add_python3_operation_files"]
-        py3_only = self.code_model.options["python3_only"]
-        if typed_py3_files and not py3_only and not self.async_mode:
-            retval: List[str] = ["try:"]
-            retval.extend(
-                [
-                    f"    {line}"
-                    for line in self._operation_group_imports_helper(
-                        filename_suffix="_py3"
-                    )
-                ]
-            )
-            retval.append("except (SyntaxError, ImportError):")
-            retval.extend(
-                [f"    {line}" for line in self._operation_group_imports_helper()]
-            )
-            return retval
-        return self._operation_group_imports_helper()
-
     def serialize(self) -> str:
         operation_group_init_template = self.env.get_template(
             "operations_folder_init.py.jinja2"

package/autorest/codegen/serializers/patch_serializer.py

@@ -19,9 +19,7 @@ class PatchSerializer:
         imports.add_submodule_import(
             "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        is_python3_file = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
-            imports=FileImportSerializer(imports, is_python3_file=is_python3_file),
-            is_python3_file=is_python3_file,
+            imports=FileImportSerializer(imports),
         )

package/autorest/codegen/serializers/request_builders_serializer.py

@@ -18,13 +18,11 @@ class RequestBuildersSerializer:
         code_model: CodeModel,
         env: Environment,
         request_builders: List[RequestBuilderType],
-        is_python3_file: bool,
     ) -> None:
         self.code_model = code_model
         self.env = env
         self.request_builders = request_builders
         self.group_name = request_builders[0].group_name
-        self.is_python3_file = is_python3_file
 
     @property
     def imports(self) -> FileImport:
@@ -49,9 +47,8 @@ class RequestBuildersSerializer:
             request_builders=[rb for rb in self.request_builders if not rb.abstract],
             imports=FileImportSerializer(
                 self.imports,
-                is_python3_file=True,
             ),
             request_builder_serializer=RequestBuilderSerializer(
-                self.code_model, async_mode=False, is_python3_file=self.is_python3_file
+                self.code_model, async_mode=False
             ),
         )

package/autorest/codegen/serializers/utils.py

@@ -7,10 +7,7 @@
 
 def method_signature_and_response_type_annotation_template(
     *,
-    is_python3_file: bool,
     method_signature: str,
     response_type_annotation: str,
 ) -> str:
-    if is_python3_file:
-        return f"{method_signature} -> {response_type_annotation}:"
-    return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
+    return f"{method_signature} -> {response_type_annotation}:"

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

@@ -6,7 +6,7 @@
 
 {{ imports }}
 
-{{ serializer.class_definition(async_mode) }}
+{{ serializer.class_definition }}
     """{{ op_tools.wrap_string(code_model.client.description, "\n") | indent }}
 
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
@@ -14,8 +14,8 @@
     {% if serializer.should_init_super %}
         super().__init__()
     {% endif %}
-    {% if code_model.client.parameters.kwargs_to_pop(async_mode) %}
-        {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}
+    {% if code_model.client.parameters.kwargs_to_pop %}
+        {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
     {% endif %}
         {% if code_model.client.has_parameterized_host %}
         {{ serializer.host_variable_name }} = {{ keywords.escape_str(code_model.client.url) }}

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

@@ -22,8 +22,8 @@ class {{ code_model.client.name }}Configuration(Configuration):  # pylint: disab
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
         super({{ code_model.client.name }}Configuration, self).__init__(**kwargs)
-    {% if code_model.config.parameters.kwargs_to_pop(async_mode) %}
-        {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}
+    {% if code_model.config.parameters.kwargs_to_pop %}
+        {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
     {% endif %}
 {% if serializer.check_required_parameters() %}
         {{ op_tools.serialize(serializer.check_required_parameters()) | indent(8) -}}

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

@@ -20,7 +20,7 @@
         "sync": {
             {% for gp in global_parameters.method | rejectattr("client_name", "equalto", "api_version") | rejectattr("is_host") %}
             {{ gp.client_name | tojson }}: {
-                "signature": {{ gp.method_signature(is_python3_file=False, async_mode=False) | tojson }},
+                "signature": {{ gp.method_signature(async_mode=False) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type(async_mode=False) | tojson }},
                 "required": {{ (not gp.optional) | tojson }}
@@ -30,7 +30,7 @@
         "async": {
             {% for gp in global_parameters.method | rejectattr("client_name", "equalto", "api_version") | rejectattr("is_host") %}
             {{ gp.client_name | tojson }}: {
-                "signature": {{ (gp.method_signature(is_python3_file=True, async_mode=True)) | tojson }},
+                "signature": {{ (gp.method_signature(async_mode=True)) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type(async_mode=True) | tojson }},
                 "required": {{ (not gp.optional) | tojson }}
@@ -53,7 +53,7 @@
                 },
                 {% if not client.has_parameterized_host %}
                 "base_url": {
-                    "signature": {{ client.parameters.host.method_signature(False, async_mode=False) | tojson }},
+                    "signature": {{ client.parameters.host.method_signature(async_mode=False) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false
@@ -75,7 +75,7 @@
                 },
                 {% if not client.has_parameterized_host %}
                 "base_url": {
-                    "signature": {{ client.parameters.host.method_signature(True, async_mode=True) | tojson }},
+                    "signature": {{ client.parameters.host.method_signature(async_mode=True) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false

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

@@ -3,21 +3,14 @@
 {{ code_model.options['license_header'] }}
 {% macro iterate_models_py3() %}
     {% for schema in schemas %}
-from .{{ code_model.get_models_filename(is_python3_file=True) }} import {{ schema }}
+from .{{ code_model.models_filename }} import {{ schema }}
     {% endfor %}
 {% endmacro %}
-
 {% if schemas %}
-    {% if code_model.options["python3_only"] %}
-{{ iterate_models_py3() }}
-    {% else %}
-try:
-    {{ iterate_models_py3() | indent-}}
-except (SyntaxError, ImportError):
-        {% for schema in schemas %}
-    from .{{ code_model.get_models_filename(is_python3_file=False) }} import {{ schema }}  # type: ignore
-        {% endfor %}
-    {% endif %}
+
+    {% for schema in schemas %}
+from .{{ code_model.models_filename }} import {{ schema }}
+    {% endfor %}
 {% endif %}
 {% if enums %}
 

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

@@ -1,5 +1,5 @@
 {% set disable = "  # pylint: disable=too-many-public-methods" if operation_group.operations | length > 20 else "" %}
-{% set base_class = ("(" + operation_group.base_class(async_mode) + ")") if operation_group.base_class(async_mode) else "" %}
+{% set base_class = ("(" + operation_group.base_class + ")") if operation_group.base_class else "" %}
 {% macro check_abstract_methods() %}
 {% if operation_group.has_abstract_operations %}
         raise_if_not_implemented(self.__class__, [

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

@@ -8,18 +8,12 @@
 
 {% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
 {{ op_tools.declare_serializer(code_model, request_builders) }}
-{%- if not is_python3_file %}
-# fmt: off
-{% endif %}
 {% for operation_group in operation_groups %}
     {% for request_builder in request_builders | selectattr("group_name", "equalto", operation_group.property_name) | rejectattr("is_overload") %}
 
         {% include "request_builder.py.jinja2" %}
     {% endfor %}
 {% endfor %}
-{% if not is_python3_file %}
-# fmt: on
-{% endif %}
 {% endif %}
 {% for operation_group in operation_groups %}
     {% include "operation_group.py.jinja2" %}

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

@@ -8,8 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python
 """
 {{ imports }}
 
-{% set type_annotation = ": List[str]" %}
-__all__{{ type_annotation if is_python3_file else "" }} = []{{ "" if is_python3_file else ("  # type" + type_annotation) }}  # Add all objects you want publicly available to users at this package level
+__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
 
 def patch_sdk():
     """Do not remove from this file.

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

@@ -4,9 +4,6 @@
 {{ imports }}
 
 {{ op_tools.declare_serializer(code_model, request_builders) }}
-{% if not is_python3_file %}
-# fmt: off
-{% endif %}
 {% for request_builder in request_builders %}
 
 {% include "request_builder.py.jinja2" %}

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

@@ -1,14 +1,9 @@
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 
-try:
-    {% for request_builder in request_builders %}
-    from ._request_builders_py3 import {{ request_builder.name }}
-    {% endfor %}
-except (SyntaxError, ImportError):
-    {% for request_builder in request_builders %}
-    from ._request_builders import {{ request_builder.name }}  # type: ignore
-    {% endfor %}
+{% for request_builder in request_builders %}
+from ._request_builders import {{ request_builder.name }}
+{% endfor %}
 
 __all__ = [
     {% for request_builder in request_builders %}

package/autorest/m4reformatter/__init__.py

@@ -494,6 +494,13 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
         in_overriden = (
             body_parameter["type"]["type"] == "combined" if body_parameter else False
         )
+        abstract = False
+        if body_parameter and (
+            body_parameter.get("entries")
+            or len(body_parameter["type"].get("types", [])) > 2
+        ):
+            # this means it's formdata or urlencoded, or there are more than 2 types of body
+            abstract = True
         return {
             "name": yaml_data["language"]["default"]["name"],
             "description": yaml_data["language"]["default"]["description"],
@@ -520,6 +527,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
             "discriminator": "operation",
             "isOverload": is_overload,
             "apiVersions": _get_api_versions(yaml_data.get("apiVersions", [])),
+            "abstract": abstract,
         }
 
     def get_operation_creator(
@@ -1072,9 +1080,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
             "skipUrlEncoding": True,
             "inOverload": False,
         }
-        if self._autorestapi.get_boolean_value(
-            "version-tolerant"
-        ) or self._autorestapi.get_boolean_value("low-level-client"):
+        if self.version_tolerant or self.low_level_client:
             parameters.append(credential)
         else:
             parameters.insert(0, credential)

package/autorest/multiapi/serializers/__init__.py

@@ -57,18 +57,14 @@ class MultiAPISerializer(object):
         )
 
         # serialize service client file
-        imports = FileImportSerializer(
-            code_model.client.imports(async_mode), is_python3_file=async_mode
-        )
+        imports = FileImportSerializer(code_model.client.imports(async_mode))
         self._autorestapi.write_file(
             _get_file_path(code_model.client.filename, async_mode),
             _render_template("client", imports=imports),
         )
 
         # serialize config file
-        imports = FileImportSerializer(
-            code_model.config.imports(async_mode), is_python3_file=async_mode
-        )
+        imports = FileImportSerializer(code_model.config.imports(async_mode))
         self._autorestapi.write_file(
             _get_file_path("_configuration", async_mode),
             _render_template("config", imports=imports),
@@ -77,8 +73,7 @@ class MultiAPISerializer(object):
         # serialize mixins
         if code_model.operation_mixin_group.mixin_operations:
             imports = FileImportSerializer(
-                code_model.operation_mixin_group.imports(async_mode),
-                is_python3_file=async_mode,
+                code_model.operation_mixin_group.imports(async_mode)
             )
             self._autorestapi.write_file(
                 _get_file_path("_operations_mixin", async_mode),

package/autorest/multiapi/serializers/import_serializer.py

@@ -54,9 +54,8 @@ def _get_import_clauses(
 
 
 class FileImportSerializer:
-    def __init__(self, file_import: FileImport, is_python3_file: bool) -> None:
+    def __init__(self, file_import: FileImport) -> None:
         self._file_import = file_import
-        self.is_python3_file = is_python3_file
 
     def _switch_typing_section_key(self, new_key: TypingSection):
         switched_dictionary = {}
@@ -84,10 +83,7 @@ class FileImportSerializer:
         return file_import_copy.imports.get(baseline_typing_section, {})
 
     def _add_type_checking_import(self):
-        if self._file_import.imports.get(TypingSection.TYPING) or (
-            not self.is_python3_file
-            and self._file_import.imports.get(TypingSection.CONDITIONAL)
-        ):
+        if self._file_import.imports.get(TypingSection.TYPING):
             self._file_import.add_submodule_import(
                 "typing", "TYPE_CHECKING", ImportType.STDLIB
             )
@@ -97,7 +93,7 @@ class FileImportSerializer:
         regular_imports = ""
         regular_imports_dict = self._get_imports_dict(
             baseline_typing_section=TypingSection.REGULAR,
-            add_conditional_typing=self.is_python3_file,
+            add_conditional_typing=True,
         )
 
         if regular_imports_dict:
@@ -108,7 +104,7 @@ class FileImportSerializer:
         typing_imports = ""
         typing_imports_dict = self._get_imports_dict(
             baseline_typing_section=TypingSection.TYPING,
-            add_conditional_typing=not self.is_python3_file,
+            add_conditional_typing=False,
         )
         if typing_imports_dict:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@autorest/python",
-    "version": "5.19.0",
+    "version": "6.0.0-rc.1",
     "description": "The Python extension for generators in AutoRest.",
     "scripts": {
         "prepare": "node run-python3.js prepare.py",
@@ -27,7 +27,7 @@
         "@autorest/system-requirements": "~1.0.0"
     },
     "devDependencies": {
-        "@microsoft.azure/autorest.testserver": "^3.3.28"
+        "@microsoft.azure/autorest.testserver": "^3.3.29"
     },
     "files": [
         "autorest/**/*.py",

package/autorest/codegen/serializers/model_generic_serializer.py

@@ -1,32 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from typing import List
-from jinja2 import Environment
-from .model_base_serializer import ModelBaseSerializer
-from ..models import ModelType, CodeModel, Property
-
-
-class ModelGenericSerializer(ModelBaseSerializer):
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        super().__init__(code_model=code_model, env=env, is_python3_file=False)
-
-    def init_line(self, model: ModelType) -> List[str]:
-        return []
-
-    def properties_to_pass_to_super(self, model: ModelType) -> str:
-        return "**kwargs"
-
-    def required_property_no_default_init(self, prop: Property) -> str:
-        return f"self.{prop.client_name} = kwargs['{prop.client_name}']"
-
-    def optional_property_init(self, prop: Property) -> str:
-        return f"self.{prop.client_name} = kwargs.get('{prop.client_name}', {prop.client_default_value_declaration})"
-
-    def initialize_standard_arg(self, prop: Property) -> str:
-        return self.initialize_standard_property(prop)
-
-    def super_call_template(self, model: ModelType) -> str:
-        return "super(" + model.name + ", self).__init__({})"