@autorest/python 6.9.2 → 6.9.4

package/autorest/_utils.py

@@ -8,6 +8,19 @@ import re
 import argparse
 
 
+def update_enum_value(
+    name: str, value: Any, description: str, enum_type: Dict[str, Any]
+) -> Dict[str, Any]:
+    return {
+        "name": name,
+        "type": "enumvalue",
+        "value": value,
+        "description": description,
+        "enumType": enum_type,
+        "valueType": enum_type["valueType"],
+    }
+
+
 def to_snake_case(name: str) -> str:
     def replace_upper_characters(m) -> str:
         match_str = m.group().lower()
@@ -107,24 +120,39 @@ KNOWN_TYPES: Dict[str, Dict[str, Any]] = {
 JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
 
 
-def build_policies(is_arm: bool, async_mode: bool) -> List[str]:
-    async_prefix = "Async" if async_mode else ""
-    policies = [
-        "policies.RequestIdPolicy(**kwargs)",
-        "self._config.headers_policy",
-        "self._config.user_agent_policy",
-        "self._config.proxy_policy",
-        "policies.ContentDecodePolicy(**kwargs)",
-        f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy()"
-        if is_arm
-        else None,
-        "self._config.redirect_policy",
-        "self._config.retry_policy",
-        "self._config.authentication_policy",
-        "self._config.custom_hook_policy",
-        "self._config.logging_policy",
-        "policies.DistributedTracingPolicy(**kwargs)",
-        "policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None",
-        "self._config.http_logging_policy",
-    ]
+def build_policies(
+    is_arm: bool, async_mode: bool, unbranded: bool = False
+) -> List[str]:
+    if not unbranded:
+        # for Azure
+        async_prefix = "Async" if async_mode else ""
+        policies = [
+            "policies.RequestIdPolicy(**kwargs)",
+            "self._config.headers_policy",
+            "self._config.user_agent_policy",
+            "self._config.proxy_policy",
+            "policies.ContentDecodePolicy(**kwargs)",
+            f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy()"
+            if is_arm
+            else None,
+            "self._config.redirect_policy",
+            "self._config.retry_policy",
+            "self._config.authentication_policy",
+            "self._config.custom_hook_policy",
+            "self._config.logging_policy",
+            "policies.DistributedTracingPolicy(**kwargs)",
+            "policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None",
+            "self._config.http_logging_policy",
+        ]
+    else:
+        # for non-Azure
+        policies = [
+            "self._config.headers_policy",
+            "self._config.user_agent_policy",
+            "self._config.proxy_policy",
+            "policies.ContentDecodePolicy(**kwargs)",
+            "self._config.retry_policy",
+            "self._config.authentication_policy",
+            "self._config.logging_policy",
+        ]
     return [p for p in policies if p]

package/autorest/codegen/__init__.py

@@ -85,6 +85,11 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
             "Please read https://aka.ms/azsdk/dpcodegen for more details."
         )
 
+    if options["unbranded"] and options["tracing"]:
+        raise ValueError(
+            "Can not set --unbranded=true and --tracing=true at the same time."
+        )
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -137,6 +142,7 @@ class CodeGenerator(Plugin):
             models_mode_default = "dpg"
 
         package_name = self.options.get("package-name")
+        unbranded = self.options.get("unbranded", False)
         options: Dict[str, Any] = {
             "azure_arm": azure_arm,
             "head_as_boolean": self.options.get("head-as-boolean", True),
@@ -148,7 +154,7 @@ class CodeGenerator(Plugin):
             "package_name": package_name,
             "package_version": self.options.get("package-version"),
             "client_side_validation": self.options.get("client-side-validation", False),
-            "tracing": self.options.get("tracing", show_operations),
+            "tracing": self.options.get("tracing", show_operations and not unbranded),
             "multiapi": self.options.get("multiapi", False),
             "polymorphic_examples": self.options.get("polymorphic-examples", 5),
             "models_mode": self.options.get("models-mode", models_mode_default).lower(),
@@ -177,6 +183,7 @@ class CodeGenerator(Plugin):
             "generate_sample": self.options.get("generate-sample", False),
             "default_api_version": self.options.get("default-api-version"),
             "from_typespec": self.options.get("from-typespec", False),
+            "unbranded": unbranded,
         }
 
         if options["builders_visibility"] is None:

package/autorest/codegen/models/__init__.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Any, Dict, Union
+from typing import Any, Dict, Union, Optional
 from .base import BaseModel
 from .base_builder import BaseBuilder, ParameterListType
 from .code_model import CodeModel
@@ -30,7 +30,7 @@ from .primitive_types import (
     UnixTimeType,
     AzureCoreType,
 )
-from .enum_type import EnumType
+from .enum_type import EnumType, EnumValue
 from .base import BaseType
 from .constant_type import ConstantType
 from .imports import FileImport, ImportType, TypingSection
@@ -86,6 +86,7 @@ __all__ = [
     "DictionaryType",
     "ListType",
     "EnumType",
+    "EnumValue",
     "FileImport",
     "ImportType",
     "TypingSection",
@@ -128,6 +129,7 @@ TYPE_TO_OBJECT = {
     "dict": DictionaryType,
     "constant": ConstantType,
     "enum": EnumType,
+    "enumvalue": EnumValue,
     "binary": BinaryType,
     "any": AnyType,
     "datetime": DatetimeType,
@@ -157,6 +159,7 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
     except KeyError:
         # Not created yet, let's create it and add it to the index
         pass
+    response: Optional[BaseType] = None
     if yaml_data["type"] == "model":
         # need to special case model to avoid recursion
         if yaml_data["base"] == "json" or not code_model.options["models_mode"]:
@@ -168,6 +171,16 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
         response = model_type(yaml_data, code_model)
         code_model.types_map[yaml_id] = response
         response.fill_instance_from_yaml(yaml_data, code_model)
+    elif yaml_data["type"] == "enum":
+        # avoid recursion because we add the parent enum type to the enum value
+        response = EnumType(
+            yaml_data,
+            code_model,
+            values=[],
+            value_type=build_type(yaml_data["valueType"], code_model),
+        )
+        code_model.types_map[yaml_id] = response
+        response.fill_instance_from_yaml(yaml_data, code_model)
     else:
         object_type = yaml_data.get("type")
         if object_type not in TYPE_TO_OBJECT:
@@ -177,6 +190,8 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
             )
             object_type = "string"
         response = TYPE_TO_OBJECT[object_type].from_yaml(yaml_data, code_model)  # type: ignore
+    if response is None:
+        raise ValueError("response can not be None")
     code_model.types_map[yaml_id] = response
     return response
 

package/autorest/codegen/models/base.py

@@ -53,14 +53,13 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
         return cls(yaml_data=yaml_data, code_model=code_model)
 
     def imports(self, **kwargs) -> FileImport:  # pylint: disable=unused-argument
-        return FileImport()
+        return FileImport(self.code_model)
 
     def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
         return self.imports(**kwargs)
 
-    @staticmethod
-    def imports_for_sample() -> FileImport:
-        return FileImport()
+    def imports_for_sample(self) -> FileImport:
+        return FileImport(self.code_model)
 
     @staticmethod
     def serialize_sample_value(value: Any) -> str:

package/autorest/codegen/models/client.py

@@ -195,7 +195,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             raise KeyError(f"No operation with id {operation_id} found.") from exc
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
 
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
@@ -225,10 +225,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ImportType.LOCAL,
         )
         file_import.add_msrest_import(
-            self.code_model,
-            ".." if async_mode else ".",
-            MsrestImportType.SerializerDeserializer,
-            TypingSection.REGULAR,
+            relative_path=".." if async_mode else ".",
+            msrest_import_type=MsrestImportType.SerializerDeserializer,
+            typing_section=TypingSection.REGULAR,
         )
         file_import.add_submodule_import(
             "azure.core.pipeline", "policies", ImportType.AZURECORE
@@ -406,7 +405,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
         return f"{super().name}Configuration"
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "azure.core.pipeline", "policies", ImportType.AZURECORE
         )

package/autorest/codegen/models/combined_type.py

@@ -103,7 +103,7 @@ class CombinedType(BaseType):
         raise ValueError("You shouldn't do instance checks on a multiple type")
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         if self.name and not kwargs.get("is_types_file"):
             file_import.add_submodule_import(
                 kwargs.pop("relative_path"),

package/autorest/codegen/models/constant_type.py

@@ -6,7 +6,7 @@
 import logging
 from typing import Dict, Any, Optional, TYPE_CHECKING
 from .base import BaseType
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport
 from .primitive_types import IntegerType, BinaryType, StringType, BooleanType
 from .utils import add_to_description
 
@@ -124,7 +124,7 @@ class ConstantType(BaseType):
         )
 
     def _imports_shared(self, **kwargs: Any):
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
         return file_import
 
@@ -134,21 +134,7 @@ class ConstantType(BaseType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = self._imports_shared(**kwargs)
         if self._is_literal:
-            file_import.add_import("sys", ImportType.STDLIB)
-            file_import.add_submodule_import(
-                "typing_extensions",
-                "Literal",
-                ImportType.BYVERSION,
-                TypingSection.REGULAR,
-                None,
-                (
-                    (
-                        (3, 8),
-                        "typing",
-                        "pylint: disable=no-name-in-module, ungrouped-imports",
-                    ),
-                ),
-            )
+            file_import.add_literal_import()
         return file_import
 
     @property

package/autorest/codegen/models/credential_types.py

@@ -182,7 +182,7 @@ class TokenCredentialType(
         return "~azure.core.credentials.TokenCredential"
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         if kwargs.get("async_mode"):
             file_import.add_submodule_import(
                 "azure.core.credentials_async",
@@ -221,7 +221,7 @@ class AzureKeyCredentialType(
         return "isinstance({}, AzureKeyCredential)"
 
     def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "azure.core.credentials",
             "AzureKeyCredential",

package/autorest/codegen/models/dictionary_type.py

@@ -123,7 +123,7 @@ class DictionaryType(BaseType):
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/enum_type.py

@@ -3,17 +3,16 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, TYPE_CHECKING, Optional
+from typing import Any, Dict, List, TYPE_CHECKING, Optional, cast
 
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
-from .base import BaseModel
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
 
-class EnumValue(BaseModel):
+class EnumValue(BaseType):
     """Model containing necessary information for a single value of an enum.
 
     :param str name: The name of this enum value
@@ -21,11 +20,70 @@ class EnumValue(BaseModel):
     :param str description: Optional. The description for this enum value
     """
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        enum_type: "EnumType",
+        value_type: BaseType,
+    ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name: str = self.yaml_data["name"]
         self.value: str = self.yaml_data["value"]
-        self.description: Optional[str] = self.yaml_data.get("description")
+        self.enum_type = enum_type
+        self.value_type = value_type
+
+    def description(self, *, is_operation_file: bool) -> str:
+        return self.yaml_data.get("description", "")
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation"""
+        return f"Literal[{self.enum_type.name}.{self.name}]"
+
+    def get_declaration(self, value=None):
+        return self.enum_type.name + "." + self.name
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return self.enum_type.name + "." + self.name
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        """The python type used for RST syntax input and type annotation."""
+
+        type_annotation = self.value_type.type_annotation(**kwargs)
+        enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
+        return f"{type_annotation} or ~{enum_type_annotation}"
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        # for better display effect, use the only value instead of var type
+        return self.value_type.get_json_template_representation(
+            optional=optional,
+            client_default_value_declaration=client_default_value_declaration,
+            description=description,
+        )
+
+    @property
+    def serialization_type(self) -> str:
+        return self.value_type.serialization_type
+
+    @property
+    def instance_check_template(self) -> str:
+        return self.value_type.instance_check_template
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport(self.code_model)
+        file_import.merge(self.value_type.imports(**kwargs))
+        file_import.add_literal_import()
+        file_import.add_submodule_import(
+            "._enums", self.enum_type.name, ImportType.LOCAL, TypingSection.REGULAR
+        )
+
+        return file_import
 
     @classmethod
     def from_yaml(
@@ -39,9 +97,14 @@ class EnumValue(BaseModel):
         :return: A created EnumValue
         :rtype: ~autorest.models.EnumValue
         """
+        from . import build_type
+
+        enum_type = cast(EnumType, code_model.lookup_type(id(yaml_data["enumType"])))
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
+            enum_type=enum_type,
+            value_type=build_type(yaml_data["valueType"], code_model),
         )
 
 
@@ -150,32 +213,24 @@ class EnumType(BaseType):
     def instance_check_template(self) -> str:
         return self.value_type.instance_check_template
 
+    def fill_instance_from_yaml(
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> None:
+        for value in yaml_data["values"]:
+            self.values.append(EnumValue.from_yaml(value, code_model))
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "EnumType":
-        """Constructs an EnumType from yaml data.
-
-        :param yaml_data: the yaml data from which we will construct this schema
-        :type yaml_data: dict[str, Any]
-
-        :return: A created EnumType
-        :rtype: ~autorest.models.EnumType
-        """
-        from . import build_type
-
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            value_type=build_type(yaml_data["valueType"], code_model),
-            values=[
-                EnumValue.from_yaml(value, code_model) for value in yaml_data["values"]
-            ],
+        raise ValueError(
+            "You shouldn't call from_yaml for EnumType to avoid recursion. "
+            "Please initial a blank EnumType, then call .fill_instance_from_yaml on the created type."
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
         operation = kwargs.pop("operation", False)
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         if self.code_model.options["models_mode"]:
             file_import.add_submodule_import(
                 "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL

package/autorest/codegen/models/imports.py

@@ -88,8 +88,9 @@ class TypeDefinition:
 
 
 class FileImport:
-    def __init__(self, imports: Optional[List[ImportModel]] = None) -> None:
-        self.imports = imports or []
+    def __init__(self, code_model: "CodeModel") -> None:
+        self.imports: List[ImportModel] = []
+        self.code_model = code_model
         # has sync and async type definitions
         self.type_definitions: Dict[str, TypeDefinition] = {}
 
@@ -183,6 +184,23 @@ class FileImport:
         )
         self.add_submodule_import("typing", "Any", ImportType.STDLIB)
 
+    def add_literal_import(self) -> None:
+        self.add_import("sys", ImportType.STDLIB)
+        self.add_submodule_import(
+            "typing_extensions",
+            "Literal",
+            ImportType.BYVERSION,
+            TypingSection.REGULAR,
+            None,
+            (
+                (
+                    (3, 8),
+                    "typing",
+                    "pylint: disable=no-name-in-module, ungrouped-imports",
+                ),
+            ),
+        )
+
     def to_dict(
         self,
     ) -> Dict[
@@ -255,12 +273,12 @@ class FileImport:
 
     def add_msrest_import(
         self,
-        code_model: "CodeModel",
+        *,
         relative_path: str,
         msrest_import_type: MsrestImportType,
         typing_section: TypingSection,
     ):
-        if code_model.options["client_side_validation"]:
+        if self.code_model.options["client_side_validation"]:
             if msrest_import_type == MsrestImportType.Module:
                 self.add_import(
                     "msrest.serialization", ImportType.AZURECORE, typing_section
@@ -274,7 +292,7 @@ class FileImport:
                         "msrest", "Deserializer", ImportType.THIRDPARTY, typing_section
                     )
         else:
-            if code_model.options["multiapi"]:
+            if self.code_model.options["multiapi"]:
                 relative_path += "."
             if msrest_import_type == MsrestImportType.Module:
                 self.add_submodule_import(

package/autorest/codegen/models/list_type.py

@@ -146,7 +146,7 @@ class ListType(BaseType):
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         if not (
             self.code_model.options["version_tolerant"]
             and self.element_type.is_xml

package/autorest/codegen/models/lro_operation.py

@@ -104,6 +104,9 @@ class LROOperationBase(OperationBase[LROResponseType]):
         """We don't want the poller to show up in ClsType, so we call super() on resposne type annotation"""
         return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
 
+    def get_poller_with_response_type(self, async_mode: bool) -> str:
+        return self.response_type_annotation(async_mode=async_mode)
+
     def get_poller(self, async_mode: bool) -> str:
         return self.responses[0].get_poller(async_mode)
 

package/autorest/codegen/models/model_type.py

@@ -268,7 +268,7 @@ class JSONModelType(ModelType):
         return "isinstance({}, MutableMapping)"
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/operation.py

@@ -230,7 +230,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def _imports_shared(
         self, async_mode: bool, **kwargs: Any  # pylint: disable=unused-argument
     ) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -254,7 +254,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
         if self.abstract:
-            return FileImport()
+            return FileImport(self.code_model)
         file_import = self._imports_shared(async_mode, **kwargs)
         for param in self.parameters.method:
             file_import.merge(
@@ -308,7 +308,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         async_mode: bool,
     ) -> FileImport:
         """Helper method to get a request builder import."""
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         if self.code_model.options["builders_visibility"] != "embedded":
             group_name = request_builder.group_name
             rest_import_path = "..." if async_mode else ".."
@@ -338,7 +338,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         self, async_mode: bool, **kwargs: Any
     ) -> FileImport:
         if self.abstract:
-            return FileImport()
+            return FileImport(self.code_model)
         file_import = self._imports_shared(async_mode, **kwargs)
 
         for param in self.parameters.method:

package/autorest/codegen/models/operation_group.py

@@ -48,7 +48,7 @@ class OperationGroup(BaseModel):
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         relative_path = ".." if async_mode else "."
         for operation in self.operations:
             file_import.merge(
@@ -79,7 +79,7 @@ class OperationGroup(BaseModel):
         return any(o for o in self.operations if o.need_validation)
 
     def imports(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
 
         relative_path = ("..." if async_mode else "..") + (
             "." if self.client.is_subclient else ""

package/autorest/codegen/models/paging_operation.py

@@ -144,7 +144,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         if self.abstract:
-            return FileImport()
+            return FileImport(self.code_model)
         file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
         if self.code_model.options["tracing"] and self.want_tracing:

package/autorest/codegen/models/parameter.py

@@ -92,6 +92,9 @@ class _ParameterBase(
         )
         self.hide_in_method: bool = self.yaml_data.get("hideInMethod", False)
 
+    def get_declaration(self, value: Any = None) -> Any:
+        return self.type.get_declaration(value)
+
     @property
     def hide_in_operation_signature(self) -> bool:
         return False
@@ -115,7 +118,7 @@ class _ParameterBase(
         if self.optional and isinstance(self.type, ConstantType):
             base_description = add_to_description(
                 base_description,
-                f"Known values are {self.type.get_declaration()} and None.",
+                f"Known values are {self.get_declaration()} and None.",
             )
         if not (self.optional or self.client_default_value):
             base_description = add_to_description(base_description, "Required.")
@@ -141,7 +144,7 @@ class _ParameterBase(
         """Declaration of parameter's client default value"""
         if self.client_default_value is None:
             return None
-        return self.type.get_declaration(self.client_default_value)
+        return self.get_declaration(self.client_default_value)
 
     def type_annotation(self, **kwargs: Any) -> str:
         kwargs["is_operation_file"] = True
@@ -165,7 +168,7 @@ class _ParameterBase(
         return self.type.serialization_type
 
     def _imports_shared(self, async_mode: bool, **_: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = FileImport(self.code_model)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.added_on: