@autorest/python 5.16.0 → 5.19.0

package/autorest/codegen/serializers/model_base_serializer.py

@@ -6,8 +6,8 @@
 from abc import abstractmethod
 from typing import cast, List
 from jinja2 import Environment
-from ..models import ObjectSchema, CodeModel, Property
-from ..models.imports import FileImport, ImportType
+from ..models import ModelType, CodeModel, Property
+from ..models.imports import FileImport, TypingSection, MsrestImportType
 from .import_serializer import FileImportSerializer
 
 
@@ -15,12 +15,14 @@ def _documentation_string(
     prop: Property, description_keyword: str, docstring_type_keyword: str
 ) -> List[str]:
     retval: List[str] = []
-    sphinx_prefix = f":{description_keyword} {prop.name}:"
+    sphinx_prefix = f":{description_keyword} {prop.client_name}:"
     retval.append(
-        f"{sphinx_prefix} {prop.description}" if prop.description else sphinx_prefix
+        f"{sphinx_prefix} {prop.description(is_operation_file=False)}"
+        if prop.description(is_operation_file=False)
+        else sphinx_prefix
     )
     retval.append(
-        f":{docstring_type_keyword} {prop.name}: {prop.schema.docstring_type}"
+        f":{docstring_type_keyword} {prop.client_name}: {prop.type.docstring_type()}"
     )
     return retval
 
@@ -42,29 +44,27 @@ class ModelBaseSerializer:
                 self.imports(), is_python3_file=self.is_python3_file
             ),
             str=str,
-            init_line=self.init_line,
-            init_args=self.init_args,
-            input_documentation_string=ModelBaseSerializer.input_documentation_string,
-            variable_documentation_string=ModelBaseSerializer.variable_documentation_string,
-            declare_model=ModelBaseSerializer.declare_model,
+            serializer=self,
         )
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_import("msrest.serialization", ImportType.AZURECORE)
-        for model in self.code_model.sorted_schemas:
-            file_import.merge(model.imports())
+        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))
         return file_import
 
     @staticmethod
-    def get_properties_to_initialize(model: ObjectSchema) -> List[Property]:
-        if model.base_models:
+    def get_properties_to_initialize(model: ModelType) -> List[Property]:
+        if model.parents:
             properties_to_initialize = list(
                 {
-                    p.name: p
-                    for bm in model.base_models
+                    p.client_name: p
+                    for bm in model.parents
                     for p in model.properties
-                    if p not in cast(ObjectSchema, bm).properties
+                    if p not in cast(ModelType, bm).properties
                     or p.is_discriminator
                     or p.constant
                 }.values()
@@ -73,14 +73,15 @@ class ModelBaseSerializer:
             properties_to_initialize = model.properties
         return properties_to_initialize
 
-    @staticmethod
-    def declare_model(model: ObjectSchema) -> str:
-        basename = "msrest.serialization.Model"
-        if model.base_models:
-            basename = ", ".join(
-                [cast(ObjectSchema, m).name for m in model.base_models]
-            )
-        return f"class {model.name}({basename}):"
+    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}"
 
     @staticmethod
     def input_documentation_string(prop: Property) -> List[str]:
@@ -91,12 +92,17 @@ class ModelBaseSerializer:
     def variable_documentation_string(prop: Property) -> List[str]:
         return _documentation_string(prop, "ivar", "vartype")
 
-    def init_args(self, model: ObjectSchema) -> List[str]:
-        init_args = []
-        properties_to_pass_to_super = self.properties_to_pass_to_super(model)
-        init_args.append(
-            f"super({model.name}, self).__init__({properties_to_pass_to_super})"
+    @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)
         )
+
+    def initialize_properties(self, model: ModelType) -> List[str]:
+        init_args = []
         for prop in ModelBaseSerializer.get_properties_to_initialize(model):
             if prop.is_discriminator:
                 discriminator_value = (
@@ -109,25 +115,32 @@ class ModelBaseSerializer:
                 else:
                     typing = "str"
                 init_args.append(
-                    f"self.{prop.name} = {discriminator_value}  # type: {typing}"
+                    f"self.{prop.client_name} = {discriminator_value}  # type: {typing}"
                 )
             elif prop.readonly:
-                init_args.append(f"self.{prop.name} = None")
+                init_args.append(f"self.{prop.client_name} = None")
             elif not prop.constant:
                 init_args.append(self.initialize_standard_arg(prop))
         return init_args
 
     def initialize_standard_property(self, prop: Property):
-        if prop.required and not prop.default_value:
+        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)
 
+    @staticmethod
+    def discriminator_docstring(model: ModelType) -> str:
+        return (
+            "You probably want to use the sub-classes and not this class directly. "
+            f"Known sub-classes are: {', '.join(v.name for v in model.discriminated_subtypes.values())}"
+        )
+
     @abstractmethod
-    def init_line(self, model: ObjectSchema) -> List[str]:
+    def init_line(self, model: ModelType) -> List[str]:
         ...
 
     @abstractmethod
-    def properties_to_pass_to_super(self, model: ObjectSchema) -> str:
+    def properties_to_pass_to_super(self, model: ModelType) -> str:
         ...
 
     @abstractmethod

package/autorest/codegen/serializers/model_generic_serializer.py

@@ -6,25 +6,27 @@
 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
 
 
 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: ObjectSchema) -> List[str]:
+    def init_line(self, model: ModelType) -> List[str]:
         return []
 
-    def properties_to_pass_to_super(self, model: ObjectSchema) -> str:
+    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.name} = kwargs['{prop.name}']"
+        return f"self.{prop.client_name} = kwargs['{prop.client_name}']"
 
     def optional_property_init(self, prop: Property) -> str:
-        default = prop.default_value_declaration
-        return f"self.{prop.name} = kwargs.get('{prop.name}', {default})"
+        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__({})"

package/autorest/codegen/serializers/model_init_serializer.py

@@ -13,12 +13,10 @@ class ModelInitSerializer:
         self.env = env
 
     def serialize(self) -> str:
-        schemas = [s.name for s in self.code_model.sorted_schemas]
+        schemas = [s.name for s in self.code_model.public_model_types]
         schemas.sort()
         enums = (
-            [e.name for e in self.code_model.enums.values()]
-            if self.code_model.enums
-            else None
+            [e.name for e in self.code_model.enums] if self.code_model.enums else None
         )
 
         if enums:

package/autorest/codegen/serializers/model_python3_serializer.py

@@ -3,10 +3,10 @@
 # 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
 
 
@@ -14,53 +14,59 @@ class ModelPython3Serializer(ModelBaseSerializer):
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         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
         ]
-        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:
+        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,9 @@ 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:
@@ -34,12 +32,6 @@ 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
@@ -67,16 +59,18 @@ class OperationGroupsSerializer:
             ),
             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(
+            request_builder_serializer=RequestBuilderSerializer(
                 self.code_model,
-                self.is_python3_file,
+                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/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/request_builders_serializer.py

@@ -6,13 +6,10 @@
 from typing import List
 from jinja2 import Environment
 
-from ..models import RequestBuilder, FileImport
+from ..models import FileImport
 from .import_serializer import FileImportSerializer
-from ..models import CodeModel
-from .builder_serializer import (
-    RequestBuilderGenericSerializer,
-    RequestBuilderPython3Serializer,
-)
+from ..models import CodeModel, RequestBuilderType
+from .builder_serializer import RequestBuilderSerializer
 
 
 class RequestBuildersSerializer:
@@ -20,55 +17,41 @@ class RequestBuildersSerializer:
         self,
         code_model: CodeModel,
         env: Environment,
-        request_builders: List[RequestBuilder],
+        request_builders: List[RequestBuilderType],
+        is_python3_file: bool,
     ) -> None:
         self.code_model = code_model
         self.env = env
         self.request_builders = request_builders
-        self.builder_group_name = request_builders[0].builder_group_name
+        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.builder_group_name == self.builder_group_name:
+            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=self.request_builders
+            code_model=self.code_model,
+            request_builders=[r for r in self.request_builders if not r.is_overload],
         )
 
-
-class RequestBuildersPython3Serializer(RequestBuildersSerializer):
     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,
+            request_builders=[rb for rb in self.request_builders if not rb.abstract],
             imports=FileImportSerializer(
                 self.imports,
                 is_python3_file=True,
             ),
-            is_python3_file=True,
-            request_builder_serializer=RequestBuilderPython3Serializer(self.code_model),
-        )
-
-
-class RequestBuildersGenericSerializer(RequestBuildersSerializer):
-    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=False,
+            request_builder_serializer=RequestBuilderSerializer(
+                self.code_model, async_mode=False, is_python3_file=self.is_python3_file
             ),
-            is_python3_file=False,
-            request_builder_serializer=RequestBuilderGenericSerializer(self.code_model),
         )