@autorest/python 6.1.11 → 6.2.0

package/autorest/codegen/models/constant_type.py

@@ -10,7 +10,7 @@ from .imports import FileImport
 from .utils import add_to_description
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,11 +28,11 @@ class ConstantType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         value_type: BaseType,
         value: Optional[str],
     ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.value_type = value_type
         self.value = value
 
@@ -79,7 +79,7 @@ class ConstantType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "ConstantType":
         """Constructs a ConstantType from yaml data.
 
@@ -93,8 +93,8 @@ class ConstantType(BaseType):
 
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            value_type=build_type(yaml_data["valueType"], code_model),
+            namespace_model=namespace_model,
+            value_type=build_type(yaml_data["valueType"], namespace_model),
             value=yaml_data["value"],
         )
 

package/autorest/codegen/models/credential_types.py

@@ -20,7 +20,7 @@ from .imports import FileImport, ImportType, TypingSection
 from .base_type import BaseType
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class _CredentialPolicyBaseType:
@@ -29,9 +29,11 @@ class _CredentialPolicyBaseType:
     Inherited by our BearerTokenCredentialPolicy and AzureKeyCredentialPolicy types.
     """
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
         self.yaml_data = yaml_data
-        self.code_model = code_model
+        self.namespace_model = namespace_model
 
     @abstractmethod
     def call(self, async_mode: bool) -> str:
@@ -47,10 +49,10 @@ class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         credential_scopes: List[str],
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.credential_scopes = credential_scopes
 
     def call(self, async_mode: bool) -> str:
@@ -59,9 +61,9 @@ class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "BearerTokenCredentialPolicyType":
-        return cls(yaml_data, code_model, yaml_data["credentialScopes"])
+        return cls(yaml_data, namespace_model, yaml_data["credentialScopes"])
 
 
 class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
@@ -74,9 +76,9 @@ class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
 
 class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel", key: str
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel", key: str
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.key = key
 
     def call(self, async_mode: bool) -> str:
@@ -84,9 +86,9 @@ class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "AzureKeyCredentialPolicyType":
-        return cls(yaml_data, code_model, yaml_data["key"])
+        return cls(yaml_data, namespace_model, yaml_data["key"])
 
 
 CredentialPolicyType = TypeVar(
@@ -107,10 +109,10 @@ class CredentialType(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         policy: CredentialPolicyType,
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.policy = policy
 
     def description(
@@ -138,15 +140,15 @@ class CredentialType(
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "CredentialType":
         from . import build_type
 
         return cls(
             yaml_data,
-            code_model,
+            namespace_model,
             policy=cast(
-                CredentialPolicyType, build_type(yaml_data["policy"], code_model)
+                CredentialPolicyType, build_type(yaml_data["policy"], namespace_model)
             ),
         )
 

package/autorest/codegen/models/dictionary_type.py

@@ -8,7 +8,7 @@ from .base_type import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
     from .model_type import ModelType
 
 
@@ -24,10 +24,10 @@ class DictionaryType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         element_type: BaseType,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.element_type = element_type
 
     @property
@@ -96,7 +96,7 @@ class DictionaryType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "DictionaryType":
         """Constructs a DictionaryType from yaml data.
 
@@ -110,11 +110,13 @@ class DictionaryType(BaseType):
 
         from . import build_type  # pylint: disable=import-outside-toplevel
 
-        element_type = build_type(yaml_data=element_schema, code_model=code_model)
+        element_type = build_type(
+            yaml_data=element_schema, namespace_model=namespace_model
+        )
 
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
+            namespace_model=namespace_model,
             element_type=element_type,
         )
 

package/autorest/codegen/models/enum_type.py

@@ -10,7 +10,7 @@ from .imports import FileImport, ImportType, TypingSection
 from .base_model import BaseModel
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class EnumValue(BaseModel):
@@ -21,15 +21,17 @@ 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:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.name: str = self.yaml_data["name"]
         self.value: str = self.yaml_data["value"]
         self.description: Optional[str] = self.yaml_data.get("description")
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "EnumValue":
         """Constructs an EnumValue from yaml data.
 
@@ -41,7 +43,7 @@ class EnumValue(BaseModel):
         """
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
+            namespace_model=namespace_model,
         )
 
 
@@ -60,11 +62,11 @@ class EnumType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         values: List["EnumValue"],
         value_type: BaseType,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.name: str = yaml_data["name"]
         self.values = values
         self.value_type = value_type
@@ -106,7 +108,7 @@ class EnumType(BaseType):
         :return: The type annotation for this schema
         :rtype: str
         """
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             model_name = f"_models.{self.name}"
             # we don't need quoted annotation in operation files, and need it in model folder files.
             if not kwargs.get("is_operation_file", False):
@@ -119,14 +121,18 @@ class EnumType(BaseType):
         return self.value_type.get_declaration(value)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             return self.name
         return self.value_type.type_annotation(**kwargs)
 
     def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input and type annotation."""
-        if self.code_model.options["models_mode"]:
-            return f"{self.value_type.type_annotation(**kwargs)} or ~{self.code_model.namespace}.models.{self.name}"
+        if self.namespace_model.options["models_mode"]:
+            type_annotation = self.value_type.type_annotation(**kwargs)
+            enum_type_annotation = (
+                f"{self.namespace_model.namespace}.models.{self.name}"
+            )
+            return f"{type_annotation} or ~{enum_type_annotation}"
         return self.value_type.type_annotation(**kwargs)
 
     def get_json_template_representation(
@@ -149,7 +155,7 @@ class EnumType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "EnumType":
         """Constructs an EnumType from yaml data.
 
@@ -163,17 +169,18 @@ class EnumType(BaseType):
 
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            value_type=build_type(yaml_data["valueType"], code_model),
+            namespace_model=namespace_model,
+            value_type=build_type(yaml_data["valueType"], namespace_model),
             values=[
-                EnumValue.from_yaml(value, code_model) for value in yaml_data["values"]
+                EnumValue.from_yaml(value, namespace_model)
+                for value in yaml_data["values"]
             ],
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
         is_operation_file = kwargs.pop("is_operation_file", False)
         file_import = FileImport()
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             file_import.add_submodule_import(
                 "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
             )
@@ -189,7 +196,7 @@ class EnumType(BaseType):
             self.value_type.imports(is_operation_file=is_operation_file, **kwargs)
         )
         relative_path = kwargs.pop("relative_path", None)
-        if self.code_model.options["models_mode"] and relative_path:
+        if self.namespace_model.options["models_mode"] and relative_path:
             # add import for enums in operations file
             file_import.add_submodule_import(
                 relative_path, "models", ImportType.LOCAL, alias="_models"

package/autorest/codegen/models/imports.py

@@ -7,7 +7,7 @@ from enum import Enum, auto
 from typing import Dict, List, Optional, Tuple, Union, Set, Mapping, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class ImportType(str, Enum):
@@ -206,12 +206,12 @@ class FileImport:
 
     def add_msrest_import(
         self,
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         relative_path: str,
         msrest_import_type: MsrestImportType,
         typing_section: TypingSection,
     ):
-        if code_model.options["client_side_validation"]:
+        if namespace_model.options["client_side_validation"]:
             if msrest_import_type == MsrestImportType.Module:
                 self.add_import(
                     "msrest.serialization", ImportType.AZURECORE, typing_section
@@ -225,7 +225,7 @@ class FileImport:
                         "msrest", "Deserializer", ImportType.THIRDPARTY, typing_section
                     )
         else:
-            if code_model.options["multiapi"]:
+            if namespace_model.options["multiapi"]:
                 relative_path += "."
             if msrest_import_type == MsrestImportType.Module:
                 self.add_submodule_import(

package/autorest/codegen/models/list_type.py

@@ -8,7 +8,7 @@ from .base_type import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
     from .model_type import ModelType
 
 
@@ -16,10 +16,10 @@ class ListType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         element_type: BaseType,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.element_type = element_type
         self.max_items: Optional[int] = yaml_data.get("maxItems")
         self.min_items: Optional[int] = yaml_data.get("minItems")
@@ -30,7 +30,10 @@ class ListType(BaseType):
         return f"[{self.element_type.serialization_type}]"
 
     def type_annotation(self, **kwargs: Any) -> str:
-        if self.code_model.options["version_tolerant"] and self.element_type.is_xml:
+        if (
+            self.namespace_model.options["version_tolerant"]
+            and self.element_type.is_xml
+        ):
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.type_annotation(**kwargs)
         return f"List[{self.element_type.type_annotation(**kwargs)}]"
@@ -62,7 +65,7 @@ class ListType(BaseType):
 
     def docstring_type(self, **kwargs: Any) -> str:
         if (
-            self.code_model.options["version_tolerant"]
+            self.namespace_model.options["version_tolerant"]
             and self.element_type.xml_metadata
         ):
             # this means we're version tolerant XML, we just return the XML element
@@ -71,7 +74,7 @@ class ListType(BaseType):
 
     def docstring_text(self, **kwargs: Any) -> str:
         if (
-            self.code_model.options["version_tolerant"]
+            self.namespace_model.options["version_tolerant"]
             and self.element_type.xml_metadata
         ):
             # this means we're version tolerant XML, we just return the XML element
@@ -125,22 +128,23 @@ class ListType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "ListType":
         from . import build_type
 
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
+            namespace_model=namespace_model,
             element_type=build_type(
-                yaml_data=yaml_data["elementType"], code_model=code_model
+                yaml_data=yaml_data["elementType"], namespace_model=namespace_model
             ),
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         if not (
-            self.code_model.options["version_tolerant"] and self.element_type.is_xml
+            self.namespace_model.options["version_tolerant"]
+            and self.element_type.is_xml
         ):
             file_import.add_submodule_import(
                 "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL

package/autorest/codegen/models/lro_operation.py

@@ -12,7 +12,8 @@ from .request_builder import RequestBuilder
 from .parameter_list import ParameterList
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
+    from .client import Client
 
 LROResponseType = TypeVar(
     "LROResponseType", bound=Union[LROResponse, LROPagingResponse]
@@ -23,7 +24,8 @@ class LROOperationBase(OperationBase[LROResponseType]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
+        client: "Client",
         name: str,
         request_builder: RequestBuilder,
         parameters: ParameterList,
@@ -35,7 +37,8 @@ class LROOperationBase(OperationBase[LROResponseType]):
         want_tracing: bool = True,
     ) -> None:
         super().__init__(
-            code_model=code_model,
+            namespace_model=namespace_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             request_builder=request_builder,
@@ -89,13 +92,18 @@ class LROOperationBase(OperationBase[LROResponseType]):
         """Initial operation that creates the first call for LRO polling"""
         return Operation(
             yaml_data=self.yaml_data,
-            code_model=self.code_model,
-            request_builder=self.code_model.lookup_request_builder(id(self.yaml_data)),
+            namespace_model=self.namespace_model,
+            client=self.client,
+            request_builder=self.namespace_model.lookup_request_builder(
+                id(self.yaml_data)
+            ),
             name=self.name[5:] + "_initial",
             overloads=self.overloads,
             parameters=self.parameters,
             responses=[
-                Response(r.yaml_data, self.code_model, headers=r.headers, type=r.type)
+                Response(
+                    r.yaml_data, self.namespace_model, headers=r.headers, type=r.type
+                )
                 for r in self.responses
             ],
             exceptions=self.exceptions,

package/autorest/codegen/models/model_type.py

@@ -13,7 +13,7 @@ from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 def _get_properties(type: "ModelType", properties: List[Property]) -> List[Property]:
@@ -47,13 +47,13 @@ class ModelType(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         *,
         properties: Optional[List[Property]] = None,
         parents: Optional[List["ModelType"]] = None,
         discriminated_subtypes: Optional[Dict[str, "ModelType"]] = None,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.name: str = self.yaml_data["name"]
         self.max_properties: Optional[int] = self.yaml_data.get("maxProperties")
         self.min_properties: Optional[int] = self.yaml_data.get("minProperties")
@@ -74,10 +74,10 @@ class ModelType(
 
     @property
     def serialization_type(self) -> str:
-        if self.code_model.options["models_mode"] == "msrest":
-            private_model_path = f"_models.{self.code_model.models_filename}."
+        if self.namespace_model.options["models_mode"] == "msrest":
+            private_model_path = f"_models.{self.namespace_model.models_filename}."
             return f"{'' if self.is_public else private_model_path}{self.name}"
-        if self.code_model.options["models_mode"] == "dpg":
+        if self.namespace_model.options["models_mode"] == "dpg":
             return f"{'' if self.is_public else '_models.'}_models.{self.name}"
         return "object"
 
@@ -86,24 +86,24 @@ class ModelType(
         return any(p.is_polymorphic for p in self.properties)
 
     def type_annotation(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             is_operation_file = kwargs.pop("is_operation_file", False)
             retval = f"_models.{self.name}"
             if not self.is_public:
-                retval = f"{self.code_model.models_filename}.{retval}"
+                retval = f"{self.namespace_model.models_filename}.{retval}"
             return retval if is_operation_file else f'"{retval}"'
         return "ET.Element" if self.is_xml else "JSON"
 
     def docstring_type(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
-            return f"~{self.code_model.namespace}.models.{self.name}"
+        if self.namespace_model.options["models_mode"]:
+            return f"~{self.namespace_model.namespace}.models.{self.name}"
         return "ET.Element" if self.is_xml else "JSON"
 
     def description(self, *, is_operation_file: bool = False) -> str:
         return "" if is_operation_file else self.yaml_data.get("description", self.name)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             return self.name
         return "XML Element" if self.is_xml else "JSON object"
 
@@ -198,7 +198,7 @@ class ModelType(
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "ModelType":
         raise ValueError(
             "You shouldn't call from_yaml for ModelType to avoid recursion. "
@@ -206,21 +206,21 @@ class ModelType(
         )
 
     def fill_instance_from_yaml(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> None:
         from . import build_type
 
         self.parents = [
-            cast(ModelType, build_type(bm, code_model))
+            cast(ModelType, build_type(bm, namespace_model))
             for bm in yaml_data.get("parents", [])
         ]
         properties = [
-            Property.from_yaml(p, code_model) for p in yaml_data["properties"]
+            Property.from_yaml(p, namespace_model) for p in yaml_data["properties"]
         ]
         self.properties = _get_properties(self, properties)
         # checking to see if this is a polymorphic class
         self.discriminated_subtypes = {
-            k: cast(ModelType, build_type(v, code_model))
+            k: cast(ModelType, build_type(v, namespace_model))
             for k, v in self.yaml_data.get("discriminatedSubtypes", {}).items()
         }
 
@@ -250,7 +250,7 @@ class ModelType(
 
     @property
     def instance_check_template(self) -> str:
-        models_mode = self.code_model.options["models_mode"]
+        models_mode = self.namespace_model.options["models_mode"]
         if models_mode == "msrest":
             return "isinstance({}, msrest.Model)"
         if models_mode == "dpg":
@@ -274,12 +274,12 @@ class ModelType(
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         relative_path = kwargs.pop("relative_path", None)
-        if self.code_model.options["models_mode"] and relative_path:
+        if self.namespace_model.options["models_mode"] and relative_path:
             # add import for models in operations file
             file_import.add_submodule_import(
                 relative_path, "models", ImportType.LOCAL, alias="_models"
             )
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.namespace_model.options["models_mode"] == "msrest":
             return file_import
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL