@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/serializers/model_python3_serializer.py

@@ -3,63 +3,70 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import cast, List
+from typing import List
 from jinja2 import Environment
 from .model_base_serializer import ModelBaseSerializer
-from ..models import ObjectSchema, CodeModel, Property
+from ..models import ModelType, CodeModel, Property
 from ..models.imports import FileImport
 
 
 class ModelPython3Serializer(ModelBaseSerializer):
-
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        super(ModelPython3Serializer, self).__init__(
-            code_model=code_model, env=env, is_python3_file=True
-        )
+        super().__init__(code_model=code_model, env=env, is_python3_file=True)
 
-    def init_line(self, model: ObjectSchema) -> List[str]:
+    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
+            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.required, reverse=True)
+        init_line_parameters.sort(key=lambda x: x.optional)
         if init_line_parameters:
-            init_properties_declaration.append("*")
+            init_properties_declaration.append("*,")
         for param in init_line_parameters:
             init_properties_declaration.append(self.initialize_standard_property(param))
 
         return init_properties_declaration
 
-    def properties_to_pass_to_super(self, model: ObjectSchema) -> str:
+    def properties_to_pass_to_super(self, model: ModelType) -> str:
         properties_to_pass_to_super = []
-        for uncast_base_model in model.base_models:
-            base_model = cast(ObjectSchema, uncast_base_model)
+        for parent in model.parents:
             for prop in model.properties:
                 if (
-                    prop in base_model.properties
+                    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.name}={prop.name}")
+                    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)
 
     def required_property_no_default_init(self, prop: Property) -> str:
-        return f"{prop.name}: {prop.type_annotation}"
+        return f"{prop.client_name}: {prop.type_annotation()},{prop.pylint_disable}"
 
     def optional_property_init(self, prop: Property) -> str:
-        default = prop.default_value_declaration
-        return f"{prop.name}: {prop.type_annotation} = {default}"
+        return (
+            f"{prop.client_name}: {prop.type_annotation()} = "
+            f"{prop.client_default_value_declaration},{prop.pylint_disable}"
+        )
 
     def initialize_standard_arg(self, prop: Property) -> str:
-        return f"self.{prop.name} = {prop.name}"
+        return f"self.{prop.client_name} = {prop.client_name}"
+
+    def super_call_template(self, model: ModelType) -> str:
+        return "super().__init__({})"
 
     def imports(self) -> FileImport:
         file_import = super(ModelPython3Serializer, self).imports()
-        for model in self.code_model.sorted_schemas:
-            init_line_parameters = [p for p in model.properties if not p.readonly and not p.is_discriminator]
+        for model in self.code_model.model_types:
+            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.model_file_imports())
+                file_import.merge(param.imports())
 
         return file_import

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -11,11 +11,10 @@ from ..models import (
     CodeModel,
     OperationGroup,
     FileImport,
-    LROOperation,
-    PagingOperation
 )
 from .import_serializer import FileImportSerializer
-from .builder_serializer import get_operation_serializer, get_request_builder_serializer
+from .builder_serializer import get_operation_serializer, RequestBuilderSerializer
+
 
 class OperationGroupsSerializer:
     def __init__(
@@ -33,38 +32,42 @@ class OperationGroupsSerializer:
         self.operation_group = operation_group
 
     def serialize(self) -> str:
-        def _is_lro(operation):
-            return isinstance(operation, LROOperation)
-
-        def _is_paging(operation):
-            return isinstance(operation, PagingOperation)
-        operation_groups = [self.operation_group] if self.operation_group else self.code_model.operation_groups
+        operation_groups = (
+            [self.operation_group]
+            if self.operation_group
+            else self.code_model.operation_groups
+        )
         imports = FileImport()
         for operation_group in operation_groups:
-            imports.merge(operation_group.imports(
-                async_mode=self.async_mode,
-            ))
+            imports.merge(
+                operation_group.imports(
+                    async_mode=self.async_mode,
+                    is_python3_file=self.is_python3_file,
+                )
+            )
 
-        template = self.env.get_or_select_template("operation_groups_container.py.jinja2")
+        template = self.env.get_or_select_template(
+            "operation_groups_container.py.jinja2"
+        )
         return template.render(
             code_model=self.code_model,
             operation_groups=operation_groups,
             imports=FileImportSerializer(
                 imports,
                 is_python3_file=self.is_python3_file,
-                async_mode=self.async_mode
+                async_mode=self.async_mode,
             ),
             async_mode=self.async_mode,
             is_python3_file=self.is_python3_file,
-            is_lro=_is_lro,
-            is_paging=_is_paging,
             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=get_request_builder_serializer(
-                self.code_model, self.is_python3_file,
+            request_builder_serializer=RequestBuilderSerializer(
+                self.code_model,
+                async_mode=False,
+                is_python3_file=self.is_python3_file,
             ),
         )

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -11,15 +11,22 @@ from ..models import CodeModel
 
 
 class OperationsInitSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool) -> None:
+    def __init__(
+        self, code_model: CodeModel, env: Environment, async_mode: bool
+    ) -> None:
         self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
 
     def _operation_group_imports_helper(self, filename_suffix: str = "") -> List[str]:
         def _get_filename(operation_group: OperationGroup) -> str:
-            prefix = "_operations" if self.code_model.options["combine_operation_files"] else operation_group.filename
+            prefix = (
+                "_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
@@ -30,20 +37,25 @@ class OperationsInitSerializer:
         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.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()
-            ])
+            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")
+        operation_group_init_template = self.env.get_template(
+            "operations_folder_init.py.jinja2"
+        )
 
         return operation_group_init_template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/parameter_serializer.py

@@ -0,0 +1,174 @@
+# -------------------------------------------------------------------------
+# 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, Sequence, Union
+from enum import Enum, auto
+
+
+from ..models import (
+    Parameter,
+    ParameterLocation,
+    ListType,
+    ParameterDelimeter,
+    RequestBuilderParameter,
+    ClientParameter,
+    ConfigParameter,
+    ParameterType,
+)
+from ..models.parameter import _ParameterBase
+
+
+class PopKwargType(Enum):
+    NO = auto()
+    SIMPLE = auto()
+    CASE_INSENSITIVE = auto()
+
+
+class ParameterSerializer:
+    @staticmethod
+    def serialize_parameter(parameter: ParameterType, serializer_name: str) -> str:
+        optional_parameters = []
+
+        if parameter.skip_url_encoding:
+            optional_parameters.append("skip_quote=True")
+
+        if parameter.delimiter and not parameter.explode:
+            if parameter.delimiter == ParameterDelimeter.COMMA:
+                div_char = ","
+            elif parameter.delimiter == ParameterDelimeter.SPACE:
+                div_char = " "
+            elif parameter.delimiter == ParameterDelimeter.PIPE:
+                div_char = "|"
+            elif parameter.delimiter == ParameterDelimeter.TAB:
+                div_char = "\t"
+            else:
+                raise ValueError(f"We do not support {parameter.delimiter} yet")
+            optional_parameters.append(f"div='{div_char}'")
+
+        if parameter.explode:
+            if not isinstance(parameter.type, ListType):
+                raise ValueError("Got a explode boolean on a non-array schema")
+            type = parameter.type.element_type
+        else:
+            type = parameter.type
+
+        serialization_constraints = type.serialization_constraints
+        if serialization_constraints:
+            optional_parameters += serialization_constraints
+
+        origin_name = parameter.full_client_name
+
+        parameters = [
+            f'"{origin_name.lstrip("_")}"',
+            "q" if parameter.explode else origin_name,
+            f"'{type.serialization_type}'",
+            *optional_parameters,
+        ]
+        parameters_line = ", ".join(parameters)
+
+        msrest_function_name = {
+            ParameterLocation.PATH: "url",
+            ParameterLocation.ENDPOINT_PATH: "url",
+            ParameterLocation.HEADER: "header",
+            ParameterLocation.QUERY: "query",
+        }[parameter.location]
+
+        serialize_line = f"{serializer_name}.{msrest_function_name}({parameters_line})"
+
+        if parameter.explode:
+            return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
+        return serialize_line
+
+    def serialize_path(
+        self,
+        parameters: Union[
+            List[Parameter],
+            List[RequestBuilderParameter],
+            List[ClientParameter],
+            List[ConfigParameter],
+        ],
+        serializer_name: str,
+    ) -> List[str]:
+        retval = ["path_format_arguments = {"]
+        retval.extend(
+            [
+                '    "{}": {},'.format(
+                    path_parameter.rest_api_name,
+                    self.serialize_parameter(path_parameter, serializer_name),
+                )
+                for path_parameter in parameters
+            ]
+        )
+        retval.append("}")
+        return retval
+
+    @staticmethod
+    def pop_kwargs_from_signature(
+        parameters: Sequence[_ParameterBase],
+        check_kwarg_dict: bool,
+        pop_headers_kwarg: PopKwargType,
+        pop_params_kwarg: PopKwargType,
+        check_client_input: bool = False,
+    ) -> List[str]:
+        retval = []
+
+        def append_pop_kwarg(key: str, pop_type: PopKwargType) -> None:
+            if PopKwargType.CASE_INSENSITIVE == pop_type:
+                retval.append(
+                    f'_{key} = case_insensitive_dict(kwargs.pop("{key}", {{}}) or {{}})'
+                )
+            elif PopKwargType.SIMPLE == pop_type:
+                retval.append(f'_{key} = kwargs.pop("{key}", {{}}) or {{}}')
+
+        append_pop_kwarg("headers", pop_headers_kwarg)
+        append_pop_kwarg("params", pop_params_kwarg)
+        if pop_headers_kwarg != PopKwargType.NO or pop_params_kwarg != PopKwargType.NO:
+            retval.append("")
+        for kwarg in parameters:
+            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}"
+                else:
+                    default_value = kwarg.client_default_value_declaration
+                if check_kwarg_dict and (
+                    kwarg.location
+                    in [ParameterLocation.HEADER, ParameterLocation.QUERY]
+                ):
+                    kwarg_dict = (
+                        "headers"
+                        if kwarg.location == ParameterLocation.HEADER
+                        else "params"
+                    )
+                    default_value = (
+                        f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
+                    )
+                retval.append(
+                    f"{kwarg.client_name} = kwargs.pop('{kwarg.client_name}', "
+                    + f"{default_value})  # type: {kwarg.type_annotation()}"
+                )
+            else:
+                type_annot = kwarg.type_annotation()
+                retval.append(
+                    f"{kwarg.client_name} = kwargs.pop('{kwarg.client_name}')  # type: {type_annot}"
+                )
+        return retval
+
+    @staticmethod
+    def serialize_method(
+        *,
+        function_def: str,
+        method_name: str,
+        need_self_param: bool,
+        method_param_signatures: List[str],
+        pylint_disable: str = "",
+    ):
+        lines: List[str] = []
+        first_line = f"{function_def} {method_name}({pylint_disable}"
+        lines.append(first_line)
+        if need_self_param:
+            lines.append("    self,")
+        lines.extend([("    " + line) for line in method_param_signatures])
+        lines.append(")")
+        return "\n".join(lines)

package/autorest/codegen/serializers/patch_serializer.py

@@ -4,12 +4,24 @@
 # license information.
 # --------------------------------------------------------------------------
 from jinja2 import Environment
+from .import_serializer import FileImportSerializer
+from ..models import CodeModel, FileImport, ImportType, TypingSection
 
 
 class PatchSerializer:
-    def __init__(self, env: Environment) -> None:
+    def __init__(self, env: Environment, code_model: CodeModel) -> None:
         self.env = env
+        self.code_model = code_model
 
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
-        return template.render()
+        imports = FileImport()
+        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,
+        )

package/autorest/codegen/serializers/request_builders_serializer.py

@@ -0,0 +1,57 @@
+# -------------------------------------------------------------------------
+# 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 ..models import FileImport
+from .import_serializer import FileImportSerializer
+from ..models import CodeModel, RequestBuilderType
+from .builder_serializer import RequestBuilderSerializer
+
+
+class RequestBuildersSerializer:
+    def __init__(
+        self,
+        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:
+        file_import = FileImport()
+        for request_builder in self.request_builders:
+            if request_builder.group_name == self.group_name:
+                file_import.merge(request_builder.imports())
+        return file_import
+
+    def serialize_init(self) -> str:
+        template = self.env.get_template("rest_init.py.jinja2")
+        return template.render(
+            code_model=self.code_model,
+            request_builders=[r for r in self.request_builders if not r.is_overload],
+        )
+
+    def serialize_request_builders(self) -> str:
+        template = self.env.get_template("request_builders.py.jinja2")
+
+        return template.render(
+            code_model=self.code_model,
+            request_builders=self.request_builders,
+            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
+            ),
+        )

package/autorest/codegen/serializers/utils.py

@@ -3,95 +3,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
-from ..models import ParameterStyle, ListSchema, Parameter
-
-
-def serialize_method(
-    *,
-    function_def: str,
-    method_name: str,
-    is_in_class: bool,
-    method_param_signatures: List[str],
-    ignore_inconsistent_return_statements: bool = False,
-):
-    lines: List[str] = []
-    first_line = f"{function_def} {method_name}("
-    if ignore_inconsistent_return_statements:
-        first_line += "  # pylint: disable=inconsistent-return-statements"
-    lines.append(first_line)
-    if is_in_class:
-        lines.append("    self,")
-    lines.extend([
-        ("    " + line)
-        for line in method_param_signatures
-    ])
-    lines.append(")")
-    return "\n".join(lines)
-
-def build_serialize_data_call(
-    parameter: Parameter, function_name: str, serializer_name: str
-) -> str:
-
-    optional_parameters = []
-
-    if parameter.skip_url_encoding:
-        optional_parameters.append("skip_quote=True")
-
-    if parameter.style and not parameter.explode:
-        if parameter.style in [ParameterStyle.simple, ParameterStyle.form]:
-            div_char = ","
-        elif parameter.style in [ParameterStyle.spaceDelimited]:
-            div_char = " "
-        elif parameter.style in [ParameterStyle.pipeDelimited]:
-            div_char = "|"
-        elif parameter.style in [ParameterStyle.tabDelimited]:
-            div_char = "\t"
-        else:
-            raise ValueError(f"Do not support {parameter.style} yet")
-        optional_parameters.append(f"div='{div_char}'")
-
-    if parameter.explode:
-        if not isinstance(parameter.schema, ListSchema):
-            raise ValueError("Got a explode boolean on a non-array schema")
-        serialization_schema = parameter.schema.element_type
-    else:
-        serialization_schema = parameter.schema
-
-    serialization_constraints = serialization_schema.serialization_constraints
-    if serialization_constraints:
-        optional_parameters += serialization_constraints
-
-    origin_name = parameter.full_serialized_name
-
-    parameters = [
-        f'"{origin_name.lstrip("_")}"',
-        "q" if parameter.explode else origin_name,
-        f"'{serialization_schema.serialization_type}'",
-        *optional_parameters
-    ]
-    parameters_line = ', '.join(parameters)
-
-    serialize_line = f'{serializer_name}.{function_name}({parameters_line})'
-
-    if parameter.explode:
-        return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
-    return serialize_line
-
-def serialize_path(
-    parameters: List[Parameter], serializer_name: str
-) -> List[str]:
-    retval = ["path_format_arguments = {"]
-    retval.extend([
-        "    \"{}\": {},".format(
-            path_parameter.rest_api_name,
-            build_serialize_data_call(path_parameter, "url", serializer_name)
-        )
-        for path_parameter in parameters
-    ])
-    retval.append("}")
-    return retval
-
 def method_signature_and_response_type_annotation_template(
     *,
     is_python3_file: bool,
@@ -101,17 +12,3 @@ def method_signature_and_response_type_annotation_template(
     if is_python3_file:
         return f"{method_signature} -> {response_type_annotation}:"
     return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
-
-def pop_kwargs_from_signature(kwargs_to_pop: List[Parameter]) -> List[str]:
-    retval = []
-    for kwarg in kwargs_to_pop:
-        if kwarg.has_default_value:
-            retval.append(
-                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}', "
-                + f"{kwarg.default_value_declaration})  # type: {kwarg.type_annotation}"
-            )
-        else:
-            retval.append(
-                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}')  # type: {kwarg.type_annotation}"
-            )
-    return retval

package/autorest/codegen/templates/MANIFEST.in.jinja2

@@ -1,5 +1,6 @@
 include *.md
 include LICENSE
+include {{ package_name.replace('-', '/') }}/py.typed
 recursive-include tests *.py
 recursive-include samples *.py *.md
 {%- for init_name in init_names %}

package/autorest/codegen/templates/{service_client.py.jinja2 → client.py.jinja2}

@@ -7,15 +7,15 @@
 {{ imports }}
 
 {{ serializer.class_definition(async_mode) }}
-    """{{ op_tools.wrap_string(code_model.description, "\n") | indent }}
+    """{{ 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.service_client.parameters.kwargs_to_pop(async_mode) %}
+    {% if code_model.client.parameters.kwargs_to_pop(async_mode) %}
         {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}
     {% endif %}
-        {% if code_model.service_client.has_parameterized_host %}
-        _{{ code_model.service_client.parameters.host_variable_name }} = {{ keywords.escape_str(code_model.service_client.parameterized_host_template) }}
+        {% if code_model.client.has_parameterized_host %}
+        {{ serializer.host_variable_name }} = {{ keywords.escape_str(code_model.client.url) }}
         {% endif %}
         {{ serializer.initialize_config() }}
         {{ serializer.initialize_pipeline_client(async_mode) }}
@@ -26,7 +26,7 @@
     {{ serializer.send_request_signature_and_response_type_annotation(async_mode) | indent }}
         {{ op_tools.serialize(serializer.send_request_description(async_mode)) | indent(8) }}
         request_copy = deepcopy(request)
-        {% if code_model.global_parameters.path %}
+        {% if code_model.client.parameters.path %}
         {{ op_tools.serialize(serializer.serialize_path()) | indent(8) }}
         request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
         {% else %}
@@ -40,9 +40,9 @@
         {% endif %}
         {{ keywords.await }}self._client.close()
 
-    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ (" -> \"" + code_model.class_name + "\"") if async_mode else "" }}:
+    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ (" -> \"" + code_model.client.name + "\"") if async_mode else "" }}:
         {% if not async_mode %}
-        # type: () -> {{ code_model.class_name }}
+        # type: () -> {{ code_model.client.name }}
         {% endif %}
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}enter__()
         return self