@autorest/python 5.17.0 → 6.0.0-rc.1

package/autorest/codegen/serializers/client_serializer.py

@@ -11,9 +11,8 @@ from .parameter_serializer import ParameterSerializer, PopKwargType
 
 
 class ClientSerializer:
-    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
+    def __init__(self, code_model: CodeModel) -> None:
         self.code_model = code_model
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
@@ -22,36 +21,32 @@ class ClientSerializer:
             method_name="__init__",
             need_self_param=True,
             method_param_signatures=self.code_model.client.parameters.method_signature(
-                async_mode or self.is_python3_file, async_mode
+                async_mode
             ),
         )
 
     def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
         init_signature = self._init_signature(async_mode)
         return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=async_mode or self.is_python3_file,
             method_signature=init_signature,
             response_type_annotation="None",
         )
 
-    def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
+    def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.client.parameters.kwargs_to_pop(
-                async_mode or self.is_python3_file,
-            ),
+            self.code_model.client.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,
         )
 
-    def class_definition(self, async_mode) -> str:
+    @property
+    def class_definition(self) -> str:
         class_name = self.code_model.client.name
         has_mixin_og = any(og for og in self.code_model.operation_groups if og.is_mixin)
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
-        elif not (async_mode or self.is_python3_file):
-            base_class = "object"
         pylint_disable = self.code_model.client.pylint_disable
         if base_class:
             return f"class {class_name}({base_class}):{pylint_disable}"
@@ -101,6 +96,14 @@ class ClientSerializer:
         except StopIteration:
             return "_endpoint"
 
+    @property
+    def should_init_super(self) -> bool:
+        return any(
+            og
+            for og in self.code_model.operation_groups
+            if og.is_mixin and og.has_abstract_operations
+        )
+
     def initialize_pipeline_client(self, async_mode: bool) -> str:
         pipeline_client_name = self.code_model.client.pipeline_class(async_mode)
         return (
@@ -138,17 +141,10 @@ class ClientSerializer:
             )
         return retval
 
-    def _send_request_signature(self, async_mode: bool) -> str:
-        is_python3_file = async_mode or self.code_model.options["python3_only"]
-        request_signature = [
+    def _send_request_signature(self) -> str:
+        send_request_signature = [
             "request: HttpRequest,"
-            if is_python3_file
-            else "request,  # type: HttpRequest"
-        ]
-        send_request_signature = (
-            request_signature
-            + self.code_model.client.parameters.method_signature_kwargs(is_python3_file)
-        )
+        ] + self.code_model.client.parameters.method_signature_kwargs
         return self.parameter_serializer.serialize_method(
             function_def="def",
             method_name=self.code_model.client.send_request_name,
@@ -159,9 +155,8 @@ class ClientSerializer:
     def send_request_signature_and_response_type_annotation(
         self, async_mode: bool
     ) -> str:
-        send_request_signature = self._send_request_signature(async_mode)
+        send_request_signature = self._send_request_signature()
         return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=async_mode or self.is_python3_file,
             method_signature=send_request_signature,
             response_type_annotation="Awaitable[AsyncHttpResponse]"
             if async_mode
@@ -224,7 +219,7 @@ class ClientSerializer:
             retval.extend(self._rest_request_example(async_mode))
         retval.append("")
         retval.append(
-            "For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart"
+            "For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request"
         )
         retval.append(f"")
         retval.append(":param request: The network request you want to make. Required.")
@@ -247,10 +242,9 @@ class ClientSerializer:
 
 
 class ConfigSerializer:
-    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
+    def __init__(self, code_model: CodeModel) -> None:
         self.code_model = code_model
         self.parameter_serializer = ParameterSerializer()
-        self.is_python3_file = is_python3_file
 
     def _init_signature(self, async_mode: bool) -> str:
         return self.parameter_serializer.serialize_method(
@@ -258,23 +252,20 @@ class ConfigSerializer:
             method_name="__init__",
             need_self_param=True,
             method_param_signatures=self.code_model.config.parameters.method_signature(
-                async_mode or self.is_python3_file, async_mode
+                async_mode
             ),
         )
 
     def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
         init_signature = self._init_signature(async_mode)
         return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=async_mode or self.is_python3_file,
             method_signature=init_signature,
             response_type_annotation="None",
         )
 
-    def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
+    def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.config.parameters.kwargs_to_pop(
-                async_mode or self.is_python3_file
-            ),
+            self.code_model.config.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,

package/autorest/codegen/serializers/general_serializer.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
+from ..models.imports import MsrestImportType
 from ..models import (
     FileImport,
     ImportType,
@@ -33,14 +34,12 @@ class GeneralSerializer:
 
         template = self.env.get_template("client.py.jinja2")
 
-        python3_only = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
-            serializer=ClientSerializer(self.code_model, is_python3_file=python3_only),
+            serializer=ClientSerializer(self.code_model),
             imports=FileImportSerializer(
                 self.code_model.client.imports(self.async_mode),
-                is_python3_file=self.async_mode or python3_only,
             ),
         )
 
@@ -73,18 +72,17 @@ class GeneralSerializer:
                 f"{self.code_model.client.name}Configuration",
                 ImportType.LOCAL,
             )
-            file_import.add_submodule_import(
-                "msrest", "Serializer", ImportType.THIRDPARTY, TypingSection.TYPING
-            )
-            file_import.add_submodule_import(
-                "msrest", "Deserializer", ImportType.THIRDPARTY, TypingSection.TYPING
+            file_import.add_msrest_import(
+                self.code_model,
+                ".." if self.async_mode else ".",
+                MsrestImportType.SerializerDeserializer,
+                TypingSection.TYPING,
             )
 
         return template.render(
             code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
-                is_python3_file=self.async_mode,
             ),
             async_mode=self.async_mode,
         )
@@ -98,15 +96,13 @@ class GeneralSerializer:
             package_name if package_name else self.code_model.client.name.lower()
         )
         template = self.env.get_template("config.py.jinja2")
-        python3_only = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
             imports=FileImportSerializer(
                 self.code_model.config.imports(self.async_mode),
-                is_python3_file=self.async_mode or python3_only,
             ),
-            serializer=ConfigSerializer(self.code_model, is_python3_file=python3_only),
+            serializer=ConfigSerializer(self.code_model),
             sdk_moniker=sdk_moniker,
         )
 
@@ -120,3 +116,7 @@ class GeneralSerializer:
         params.update(self.code_model.options)
         params.update(self.code_model.package_dependency)
         return template.render(code_model=self.code_model, **params)
+
+    def serialize_serialization_file(self) -> str:
+        template = self.env.get_template("serialization.py.jinja2")
+        return template.render(code_model=self.code_model)

package/autorest/codegen/serializers/import_serializer.py

@@ -58,11 +58,8 @@ def _get_import_clauses(imports: List[ImportModel], delimiter: str) -> List[str]
 
 
 class FileImportSerializer:
-    def __init__(
-        self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False
-    ) -> None:
+    def __init__(self, file_import: FileImport, async_mode: bool = False) -> None:
         self.file_import = file_import
-        self.is_python3_file = is_python3_file
         self.async_mode = async_mode
 
     def _get_imports_list(
@@ -82,20 +79,14 @@ class FileImportSerializer:
         return file_import_copy.get_imports_from_section(baseline_typing_section)
 
     def _add_type_checking_import(self):
-        any_typing = any(
-            self.file_import.get_imports_from_section(TypingSection.TYPING)
-        )
-        conditional_and_not_py3 = not self.is_python3_file and any(
-            self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
-        )
-        if any_typing or conditional_and_not_py3:
+        if any(self.file_import.get_imports_from_section(TypingSection.TYPING)):
             self.file_import.add_submodule_import(
                 "typing", "TYPE_CHECKING", ImportType.STDLIB
             )
 
     def _get_typing_definitions(self) -> str:
         def declare_defintion(
-            spacing: str, type_name: str, type_definition: TypeDefinition
+            type_name: str, type_definition: TypeDefinition
         ) -> List[str]:
             ret: List[str] = []
             definition_value = (
@@ -112,21 +103,20 @@ class FileImportSerializer:
                 ):
                     if version is not None:
                         ret.append(
-                            "{}{} sys.version_info >= {}:".format(
-                                spacing, "if" if i == 0 else "elif", version
+                            "{} sys.version_info >= {}:".format(
+                                "if" if i == 0 else "elif", version
                             )
                         )
                     elif i > 0:
-                        ret.append("{}else:".format(spacing))
+                        ret.append("else:")
                     for import_clause in _get_import_clauses(
                         [type_definition.version_imports[version]], "\n"
                     ):
                         ret.append(
-                            "{}{}{}".format(
+                            "{}{}".format(
                                 "    "
                                 if len(versions) > 1 or version is not None
                                 else "",
-                                spacing,
                                 import_clause,
                             )
                         )
@@ -134,15 +124,14 @@ class FileImportSerializer:
                             ret[
                                 -1
                             ] += "  # type: ignore  # pylint: disable=ungrouped-imports"
-            ret.append("{}{} = {}".format(spacing, type_name, definition_value))
+            ret.append("{} = {}".format(type_name, definition_value))
             return ret
 
         if not self.file_import.type_definitions:
             return ""
-        spacing = "" if self.is_python3_file else "    "
         declarations: List[str] = [""]
         for type_name, value in self.file_import.type_definitions.items():
-            declarations.extend(declare_defintion(spacing, type_name, value))
+            declarations.extend(declare_defintion(type_name, value))
         return "\n".join(declarations)
 
     def __str__(self) -> str:
@@ -150,7 +139,7 @@ class FileImportSerializer:
         regular_imports = ""
         regular_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.REGULAR,
-            add_conditional_typing=self.is_python3_file,
+            add_conditional_typing=True,
         )
 
         if regular_imports_list:
@@ -161,7 +150,7 @@ class FileImportSerializer:
         typing_imports = ""
         typing_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.TYPING,
-            add_conditional_typing=not self.is_python3_file,
+            add_conditional_typing=False,
         )
         if typing_imports_list:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "

package/autorest/codegen/serializers/metadata_serializer.py

@@ -143,13 +143,11 @@ class MetadataSerializer:
                 get_operation_serializer,
                 code_model=self.code_model,
                 async_mode=True,
-                is_python3_file=True,
             ),
             get_sync_operation_serializer=functools.partial(
                 get_operation_serializer,
                 code_model=self.code_model,
                 async_mode=False,
-                is_python3_file=False,
             ),
             has_credential=bool(self.code_model.credential),
         )

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,37 +113,53 @@ 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:
         return (
             "You probably want to use the sub-classes and not this class directly. "
-            f"Known sub-classes are: {', '.join(model.discriminated_subtypes.values())}"
+            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

@@ -3,12 +3,11 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+
+
 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) }}