@autorest/python 5.18.0 → 6.0.0

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

@@ -3,11 +3,10 @@
 # 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
-from ..models.imports import FileImport, ImportType
+from ..models.imports import FileImport, TypingSection, MsrestImportType
 from .import_serializer import FileImportSerializer
 
 
@@ -27,31 +26,33 @@ 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,
         )
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_import("msrest.serialization", ImportType.AZURECORE)
+        file_import.add_msrest_import(
+            self.code_model, "..", MsrestImportType.Module, TypingSection.REGULAR
+        )
         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
@@ -71,9 +72,12 @@ class ModelBaseSerializer:
             properties_to_initialize = model.properties
         return properties_to_initialize
 
-    @staticmethod
-    def declare_model(model: ModelType) -> str:
-        basename = "msrest.serialization.Model"
+    def declare_model(self, model: ModelType) -> str:
+        basename = (
+            "msrest.serialization.Model"
+            if self.code_model.options["client_side_validation"]
+            else "_serialization.Model"
+        )
         if model.parents:
             basename = ", ".join([cast(ModelType, m).name for m in model.parents])
         return f"class {model.name}({basename}):{model.pylint_disable}"
@@ -87,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}'"
@@ -115,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:
@@ -130,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]:
-        ...
-
-    @abstractmethod
-    def properties_to_pass_to_super(self, model: ModelType) -> 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 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,20 +51,19 @@ 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:
@@ -46,12 +44,11 @@ class RequestBuildersSerializer:
 
         return template.render(
             code_model=self.code_model,
-            request_builders=self.request_builders,
+            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,13 +6,16 @@
 
 {{ 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 }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
-    {% if code_model.client.parameters.kwargs_to_pop(async_mode) %}
-        {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}
+    {% if serializer.should_init_super %}
+        super().__init__()
+    {% endif %}
+    {% 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,14 @@
 {% 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__, [
+        {% for operation in operation_group.operations if operation.abstract %}
+            '{{operation.name}}',
+        {% endfor %}
+        ])
+{% endif %}
+{% endmacro %}
 class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
 {% if not operation_group.is_mixin %}
     """
@@ -11,7 +20,7 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
         :attr:`{{ operation_group.property_name }}` attribute.
     """
 
-{% if code_model.public_model_types and code_model.options["models_mode"] %}
+{% if code_model.public_model_types and code_model.options["models_mode"]%}
     models = _models
 
 {% endif %}
@@ -21,9 +30,13 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
         self._config = input_args.pop(0) if input_args else kwargs.pop("config")
         self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
         self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
+{{ check_abstract_methods() }}
+{% elif operation_group.has_abstract_operations %}
 
+    def __init__(self){{ return_none_type_annotation }}:
+{{ check_abstract_methods() }}
 {% endif %}
-{% for operation in operation_group.operations %}
+{% for operation in operation_group.operations if not operation.abstract %}
 
 {% set request_builder = operation.request_builder %}
 {% set operation_serializer = get_operation_serializer(operation) %}

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

@@ -7,19 +7,13 @@
 {{ imports }}
 
 {% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
-{{ op_tools.declare_serializer(code_model) }}
-{%- if not is_python3_file %}
-# fmt: off
-{% endif %}
+{{ op_tools.declare_serializer(code_model, request_builders) }}
 {% for operation_group in operation_groups %}
-    {% for request_builder in code_model.request_builders | selectattr("group_name", "equalto", operation_group.property_name) | rejectattr("is_overload") %}
+    {% 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/operation_tools.jinja2

@@ -50,11 +50,13 @@ Example:
     {% endif %}
 {% endfor %}{% endmacro %}
 
-{% macro declare_serializer(code_model) %}
+{% macro declare_serializer(code_model, request_builders) %}
+{% if request_builders %}
 _SERIALIZER = Serializer()
     {% if not code_model.options["client_side_validation"] %}
 _SERIALIZER.client_side_validation = False
     {% endif %}
+{% endif %}
 {% endmacro %}
 
 {% macro generate_overloads(operation_serializer, operation) %}

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_builder.py.jinja2

@@ -5,12 +5,6 @@
     {{ op_tools.description(request_builder, request_builder_serializer) | indent }}
 {% endif %}
 {% if not request_builder.is_overload %}
-    {% if request_builder.abstract %}
-    raise NotImplementedError(
-        "You need to write a custom operation for '{{ request_builder.name }}'. "
-        "Please refer to https://aka.ms/azsdk/python/dpcodegen/python/customize to learn how to customize."
-    )
-    {% else %}
         {% if request_builder_serializer.pop_kwargs_from_signature(request_builder) %}
     {{ op_tools.serialize(request_builder_serializer.pop_kwargs_from_signature(request_builder)) | indent }}
         {%- endif -%}
@@ -31,5 +25,4 @@
     {{ op_tools.serialize(request_builder_serializer.serialize_headers(request_builder)) | indent }}
         {% endif %}
     {{ op_tools.serialize(request_builder_serializer.create_http_request(request_builder)) | indent }}
-        {% endif %}
 {% endif %}

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

@@ -3,10 +3,7 @@
 {{ code_model.options['license_header'] }}
 {{ imports }}
 
-{{ op_tools.declare_serializer(code_model) }}
-{% if not is_python3_file %}
-# fmt: off
-{% endif %}
+{{ op_tools.declare_serializer(code_model, request_builders) }}
 {% 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 %}