@autorest/python 6.2.0 → 6.2.2

package/autorest/codegen/models/enum_type.py

@@ -5,12 +5,12 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict, List, TYPE_CHECKING, Optional
 
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
-from .base_model import BaseModel
+from .base import BaseModel
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 
 class EnumValue(BaseModel):
@@ -21,17 +21,15 @@ class EnumValue(BaseModel):
     :param str description: Optional. The description for this enum value
     """
 
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> 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")
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "EnumValue":
         """Constructs an EnumValue from yaml data.
 
@@ -43,7 +41,7 @@ class EnumValue(BaseModel):
         """
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
+            code_model=code_model,
         )
 
 
@@ -62,11 +60,11 @@ class EnumType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         values: List["EnumValue"],
         value_type: BaseType,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name: str = yaml_data["name"]
         self.values = values
         self.value_type = value_type
@@ -108,7 +106,7 @@ class EnumType(BaseType):
         :return: The type annotation for this schema
         :rtype: str
         """
-        if self.namespace_model.options["models_mode"]:
+        if self.code_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):
@@ -121,17 +119,15 @@ class EnumType(BaseType):
         return self.value_type.get_declaration(value)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        if self.namespace_model.options["models_mode"]:
+        if self.code_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.namespace_model.options["models_mode"]:
+        if self.code_model.options["models_mode"]:
             type_annotation = self.value_type.type_annotation(**kwargs)
-            enum_type_annotation = (
-                f"{self.namespace_model.namespace}.models.{self.name}"
-            )
+            enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
             return f"{type_annotation} or ~{enum_type_annotation}"
         return self.value_type.type_annotation(**kwargs)
 
@@ -155,7 +151,7 @@ class EnumType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "EnumType":
         """Constructs an EnumType from yaml data.
 
@@ -169,18 +165,17 @@ class EnumType(BaseType):
 
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            value_type=build_type(yaml_data["valueType"], namespace_model),
+            code_model=code_model,
+            value_type=build_type(yaml_data["valueType"], code_model),
             values=[
-                EnumValue.from_yaml(value, namespace_model)
-                for value in yaml_data["values"]
+                EnumValue.from_yaml(value, code_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.namespace_model.options["models_mode"]:
+        if self.code_model.options["models_mode"]:
             file_import.add_submodule_import(
                 "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
             )
@@ -196,7 +191,7 @@ class EnumType(BaseType):
             self.value_type.imports(is_operation_file=is_operation_file, **kwargs)
         )
         relative_path = kwargs.pop("relative_path", None)
-        if self.namespace_model.options["models_mode"] and relative_path:
+        if self.code_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

@@ -4,10 +4,10 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum, auto
-from typing import Dict, List, Optional, Tuple, Union, Set, Mapping, TYPE_CHECKING
+from typing import Dict, List, Optional, Tuple, Union, Set, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 
 class ImportType(str, Enum):
@@ -15,6 +15,7 @@ class ImportType(str, Enum):
     THIRDPARTY = "thirdparty"
     AZURECORE = "azurecore"
     LOCAL = "local"
+    BYVERSION = "by_version"
 
 
 class TypingSection(str, Enum):
@@ -42,12 +43,19 @@ class ImportModel:
         *,
         submodule_name: Optional[str] = None,
         alias: Optional[str] = None,
+        version_modules: Optional[
+            Tuple[Tuple[Tuple[int, int], str, Optional[str]]]
+        ] = None,
     ):
         self.typing_section = typing_section
         self.import_type = import_type
         self.module_name = module_name
         self.submodule_name = submodule_name
         self.alias = alias
+        # version_modules: this field is for imports submodule from specified module by python version.
+        #                  It's a list of "python version, module_name, comments".
+        #                  The python version is in form of (major, minor), for instance (3, 9) stands for py3.9.
+        self.version_modules = version_modules
 
     def __eq__(self, other):
         try:
@@ -74,14 +82,9 @@ class TypeDefinition:
         self,
         sync_definition: str,
         async_definition: str,
-        version_imports: Mapping[Optional[Tuple[int, int]], ImportModel] = None,
     ):
-        # version_imports: a map of "python version -> ImportModel".
-        #                  The python version is in form of (major, minor), for instance (3, 9) stands for py3.9.
-        #                  If the python version is None, it's a default ImportModel.
         self.sync_definition = sync_definition
         self.async_definition = async_definition
-        self.version_imports = version_imports
 
 
 class FileImport:
@@ -114,6 +117,9 @@ class FileImport:
         import_type: ImportType,
         typing_section: TypingSection = TypingSection.REGULAR,
         alias: Optional[str] = None,
+        version_modules: Optional[
+            Tuple[Tuple[Tuple[int, int], str, Optional[str]]]
+        ] = None,
     ) -> None:
         """Add an import to this import block."""
         self._append_import(
@@ -123,6 +129,7 @@ class FileImport:
                 module_name=module_name,
                 submodule_name=submodule_name,
                 alias=alias,
+                version_modules=version_modules,
             )
         )
 
@@ -148,10 +155,9 @@ class FileImport:
         type_name: str,
         type_value: str,
         async_type_value: Optional[str] = None,
-        version_imports: Mapping[Optional[Tuple[int, int]], ImportModel] = None,
     ):
         self.type_definitions[type_name] = TypeDefinition(
-            type_value, async_type_value or type_value, version_imports
+            type_value, async_type_value or type_value
         )
 
     def merge(self, file_import: "FileImport") -> None:
@@ -162,24 +168,18 @@ class FileImport:
 
     def define_mutable_mapping_type(self) -> None:
         """Helper function for defining the mutable mapping type"""
+        self.add_import("sys", ImportType.STDLIB)
+        self.add_submodule_import(
+            "typing",
+            "MutableMapping",
+            ImportType.BYVERSION,
+            TypingSection.REGULAR,
+            None,
+            (((3, 9), "collections.abc", None),),
+        )
         self.define_mypy_type(
             "JSON",
             "MutableMapping[str, Any] # pylint: disable=unsubscriptable-object",
-            None,
-            {
-                (3, 9): ImportModel(
-                    TypingSection.CONDITIONAL,
-                    ImportType.STDLIB,
-                    "collections.abc",
-                    submodule_name="MutableMapping",
-                ),
-                None: ImportModel(
-                    TypingSection.CONDITIONAL,
-                    ImportType.STDLIB,
-                    "typing",
-                    submodule_name="MutableMapping",
-                ),
-            },
         )
         self.add_submodule_import("typing", "Any", ImportType.STDLIB)
 
@@ -187,18 +187,67 @@ class FileImport:
         self,
     ) -> Dict[
         TypingSection,
-        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        Dict[
+            ImportType,
+            Dict[
+                str,
+                Set[
+                    Optional[
+                        Union[
+                            str,
+                            Tuple[str, str],
+                            Tuple[
+                                str,
+                                Optional[str],
+                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                            ],
+                        ]
+                    ]
+                ],
+            ],
+        ],
     ]:
         retval: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[str, str],
+                                Tuple[
+                                    str,
+                                    Optional[str],
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = dict()
         for i in self.imports:
-            name_import: Optional[Union[str, Tuple[str, str]]] = None
+            name_import: Optional[
+                Union[
+                    str,
+                    Tuple[str, str],
+                    Tuple[
+                        str,
+                        Optional[str],
+                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                    ],
+                ]
+            ] = None
             if i.submodule_name:
-                name_import = (
-                    (i.submodule_name, i.alias) if i.alias else i.submodule_name
-                )
+                if i.version_modules:
+                    name_import = (i.submodule_name, i.alias, i.version_modules)
+                elif i.alias:
+                    name_import = (i.submodule_name, i.alias)
+                else:
+                    name_import = i.submodule_name
             retval.setdefault(i.typing_section, dict()).setdefault(
                 i.import_type, dict()
             ).setdefault(i.module_name, set()).add(name_import)
@@ -206,12 +255,12 @@ class FileImport:
 
     def add_msrest_import(
         self,
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         relative_path: str,
         msrest_import_type: MsrestImportType,
         typing_section: TypingSection,
     ):
-        if namespace_model.options["client_side_validation"]:
+        if code_model.options["client_side_validation"]:
             if msrest_import_type == MsrestImportType.Module:
                 self.add_import(
                     "msrest.serialization", ImportType.AZURECORE, typing_section
@@ -225,7 +274,7 @@ class FileImport:
                         "msrest", "Deserializer", ImportType.THIRDPARTY, typing_section
                     )
         else:
-            if namespace_model.options["multiapi"]:
+            if code_model.options["multiapi"]:
                 relative_path += "."
             if msrest_import_type == MsrestImportType.Module:
                 self.add_submodule_import(

package/autorest/codegen/models/list_type.py

@@ -4,11 +4,11 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import Any, Dict, Optional, Union, TYPE_CHECKING, List
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .model_type import ModelType
 
 
@@ -16,10 +16,10 @@ class ListType(BaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         element_type: BaseType,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        super().__init__(yaml_data=yaml_data, code_model=code_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,10 +30,7 @@ class ListType(BaseType):
         return f"[{self.element_type.serialization_type}]"
 
     def type_annotation(self, **kwargs: Any) -> str:
-        if (
-            self.namespace_model.options["version_tolerant"]
-            and self.element_type.is_xml
-        ):
+        if self.code_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)}]"
@@ -65,7 +62,7 @@ class ListType(BaseType):
 
     def docstring_type(self, **kwargs: Any) -> str:
         if (
-            self.namespace_model.options["version_tolerant"]
+            self.code_model.options["version_tolerant"]
             and self.element_type.xml_metadata
         ):
             # this means we're version tolerant XML, we just return the XML element
@@ -74,7 +71,7 @@ class ListType(BaseType):
 
     def docstring_text(self, **kwargs: Any) -> str:
         if (
-            self.namespace_model.options["version_tolerant"]
+            self.code_model.options["version_tolerant"]
             and self.element_type.xml_metadata
         ):
             # this means we're version tolerant XML, we just return the XML element
@@ -128,23 +125,22 @@ class ListType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "ListType":
         from . import build_type
 
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
+            code_model=code_model,
             element_type=build_type(
-                yaml_data=yaml_data["elementType"], namespace_model=namespace_model
+                yaml_data=yaml_data["elementType"], code_model=code_model
             ),
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         if not (
-            self.namespace_model.options["version_tolerant"]
-            and self.element_type.is_xml
+            self.code_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,7 @@ from .request_builder import RequestBuilder
 from .parameter_list import ParameterList
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .client import Client
 
 LROResponseType = TypeVar(
@@ -24,7 +24,7 @@ class LROOperationBase(OperationBase[LROResponseType]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
         name: str,
         request_builder: RequestBuilder,
@@ -37,7 +37,7 @@ class LROOperationBase(OperationBase[LROResponseType]):
         want_tracing: bool = True,
     ) -> None:
         super().__init__(
-            namespace_model=namespace_model,
+            code_model=code_model,
             client=client,
             yaml_data=yaml_data,
             name=name,
@@ -92,18 +92,14 @@ class LROOperationBase(OperationBase[LROResponseType]):
         """Initial operation that creates the first call for LRO polling"""
         return Operation(
             yaml_data=self.yaml_data,
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             client=self.client,
-            request_builder=self.namespace_model.lookup_request_builder(
-                id(self.yaml_data)
-            ),
+            request_builder=self.client.lookup_request_builder(id(self.yaml_data)),
             name=self.name[5:] + "_initial",
             overloads=self.overloads,
             parameters=self.parameters,
             responses=[
-                Response(
-                    r.yaml_data, self.namespace_model, headers=r.headers, type=r.type
-                )
+                Response(r.yaml_data, self.code_model, headers=r.headers, type=r.type)
                 for r in self.responses
             ],
             exceptions=self.exceptions,

package/autorest/codegen/models/model_type.py

@@ -7,13 +7,13 @@ from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 
 from autorest.codegen.models.utils import add_to_pylint_disable
-from .base_type import BaseType
+from .base import BaseType
 from .constant_type import ConstantType
 from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 
 def _get_properties(type: "ModelType", properties: List[Property]) -> List[Property]:
@@ -47,13 +47,13 @@ class ModelType(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         *,
         properties: Optional[List[Property]] = None,
         parents: Optional[List["ModelType"]] = None,
         discriminated_subtypes: Optional[Dict[str, "ModelType"]] = None,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        super().__init__(yaml_data=yaml_data, code_model=code_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.namespace_model.options["models_mode"] == "msrest":
-            private_model_path = f"_models.{self.namespace_model.models_filename}."
+        if self.code_model.options["models_mode"] == "msrest":
+            private_model_path = f"_models.{self.code_model.models_filename}."
             return f"{'' if self.is_public else private_model_path}{self.name}"
-        if self.namespace_model.options["models_mode"] == "dpg":
+        if self.code_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.namespace_model.options["models_mode"]:
+        if self.code_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.namespace_model.models_filename}.{retval}"
+                retval = f"{self.code_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.namespace_model.options["models_mode"]:
-            return f"~{self.namespace_model.namespace}.models.{self.name}"
+        if self.code_model.options["models_mode"]:
+            return f"~{self.code_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.namespace_model.options["models_mode"]:
+        if self.code_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], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "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], namespace_model: "NamespaceModel"
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> None:
         from . import build_type
 
         self.parents = [
-            cast(ModelType, build_type(bm, namespace_model))
+            cast(ModelType, build_type(bm, code_model))
             for bm in yaml_data.get("parents", [])
         ]
         properties = [
-            Property.from_yaml(p, namespace_model) for p in yaml_data["properties"]
+            Property.from_yaml(p, code_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, namespace_model))
+            k: cast(ModelType, build_type(v, code_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.namespace_model.options["models_mode"]
+        models_mode = self.code_model.options["models_mode"]
         if models_mode == "msrest":
             return "isinstance({}, msrest.Model)"
         if models_mode == "dpg":
@@ -274,17 +274,16 @@ class ModelType(
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         relative_path = kwargs.pop("relative_path", None)
-        if self.namespace_model.options["models_mode"] and relative_path:
+        if self.code_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.namespace_model.options["models_mode"] == "msrest":
+        if self.code_model.options["models_mode"] == "msrest":
             return file_import
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        file_import.add_import("sys", ImportType.STDLIB)
         file_import.define_mutable_mapping_type()
         if self.is_xml:
             file_import.add_submodule_import(