@autorest/python 5.15.0 → 5.16.0

package/autorest/codegen/models/dictionary_schema.py

@@ -3,10 +3,14 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, TYPE_CHECKING
 from .base_schema import BaseSchema
 from .imports import FileImport, ImportType, TypingSection
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
 class DictionarySchema(BaseSchema):
     """Schema for dictionaries that will be serialized.
 
@@ -18,11 +22,11 @@ class DictionarySchema(BaseSchema):
 
     def __init__(
         self,
-        namespace: str,
         yaml_data: Dict[str, Any],
-        element_type: "BaseSchema"
+        code_model: "CodeModel",
+        element_type: "BaseSchema",
     ) -> None:
-        super(DictionarySchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.element_type = element_type
 
     @property
@@ -55,20 +59,19 @@ class DictionarySchema(BaseSchema):
         return f"dict[str, {self.element_type.docstring_type}]"
 
     def xml_serialization_ctxt(self) -> Optional[str]:
-        raise NotImplementedError("Dictionary schema does not support XML serialization.")
+        raise NotImplementedError(
+            "Dictionary schema does not support XML serialization."
+        )
 
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         return {
-            f'"{"str"}"' : self.element_type.get_json_template_representation(**kwargs)
-        }
-
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        return {
-            f'"{"str"}"' : self.element_type.get_files_and_data_template_representation(**kwargs)
+            f'"{"str"}"': self.element_type.get_json_template_representation(**kwargs)
         }
 
     @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs: Any) -> "DictionarySchema":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "DictionarySchema":
         """Constructs a DictionarySchema from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -81,19 +84,19 @@ class DictionarySchema(BaseSchema):
 
         from . import build_schema  # pylint: disable=import-outside-toplevel
 
-        element_type = build_schema(
-            yaml_data=element_schema, **kwargs
-        )
+        element_type = build_schema(yaml_data=element_schema, code_model=code_model)
 
         return cls(
-            namespace=namespace,
             yaml_data=yaml_data,
+            code_model=code_model,
             element_type=element_type,
         )
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
         file_import.merge(self.element_type.imports())
         return file_import
 

package/autorest/codegen/models/enum_schema.py

@@ -3,11 +3,14 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, Optional, Set, Type
+from typing import Any, Dict, List, Optional, Set, Type, TYPE_CHECKING
 from .base_schema import BaseSchema
 from .primitive_schemas import PrimitiveSchema, get_primitive_schema, StringSchema
 from .imports import FileImport, ImportType, TypingSection
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 
 class EnumValue:
     """Model containing necessary information for a single value of an enum.
@@ -17,7 +20,9 @@ class EnumValue:
     :param str description: Optional. The description for this enum value
     """
 
-    def __init__(self, name: str, value: str, description: Optional[str] = None) -> None:
+    def __init__(
+        self, name: str, value: str, description: Optional[str] = None
+    ) -> None:
         self.name = name
         self.value = value
         self.description = description
@@ -53,14 +58,14 @@ class EnumSchema(BaseSchema):
 
     def __init__(
         self,
-        namespace: str,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         description: str,
         name: str,
         values: List["EnumValue"],
         enum_type: PrimitiveSchema,
     ) -> None:
-        super(EnumSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.description = description
         self.name = name
         self.values = values
@@ -95,9 +100,8 @@ class EnumSchema(BaseSchema):
 
     @property
     def docstring_type(self) -> str:
-        """The python type used for RST syntax input and type annotation.
-        """
-        return f"{self.enum_type.type_annotation()} or ~{self.namespace}.models.{self.name}"
+        """The python type used for RST syntax input and type annotation."""
+        return f"{self.enum_type.type_annotation()} or ~{self.code_model.namespace}.models.{self.name}"
 
     @staticmethod
     def _get_enum_values(yaml_data: List[Dict[str, Any]]) -> List["EnumValue"]:
@@ -121,21 +125,23 @@ class EnumSchema(BaseSchema):
 
     def _template_kwargs(self, **kwargs: Any) -> Any:
         if len(self.values) == 1 and not kwargs.get("default_value_declaration"):
-            kwargs['default_value_declaration'] = self.enum_type.get_declaration(self.values[0].value)
+            kwargs["default_value_declaration"] = self.enum_type.get_declaration(
+                self.values[0].value
+            )
         description = kwargs.pop("description", "")
         kwargs["description"] = description
         return kwargs
 
-
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         # for better display effect, use the only value instead of var type
-        return self.enum_type.get_json_template_representation(**self._template_kwargs(**kwargs))
-
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        return self.enum_type.get_files_and_data_template_representation(**self._template_kwargs(**kwargs))
+        return self.enum_type.get_json_template_representation(
+            **self._template_kwargs(**kwargs)
+        )
 
     @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs: Any) -> "EnumSchema":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "EnumSchema":
         """Constructs an EnumSchema from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -148,13 +154,13 @@ class EnumSchema(BaseSchema):
 
         # choice type doesn't always exist. if there is no choiceType, we default to string
         if yaml_data.get("choiceType"):
-            enum_type = get_primitive_schema(namespace, yaml_data["choiceType"])
+            enum_type = get_primitive_schema(yaml_data["choiceType"], code_model)
         else:
-            enum_type = StringSchema(namespace, {"type": "str"})
+            enum_type = StringSchema({"type": "str"}, code_model)
         values = EnumSchema._get_enum_values(yaml_data["choices"])
         return cls(
-            namespace=namespace,
             yaml_data=yaml_data,
+            code_model=code_model,
             description=yaml_data["language"]["python"]["description"],
             name=name,
             values=values,
@@ -163,13 +169,14 @@ class EnumSchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
         file_import.merge(self.enum_type.imports())
         return file_import
 
 
 class HiddenModelEnumSchema(EnumSchema):
-
     def imports(self) -> FileImport:
         file_import = FileImport()
         file_import.merge(self.enum_type.imports())
@@ -185,7 +192,9 @@ class HiddenModelEnumSchema(EnumSchema):
 
     @property
     def docstring_text(self) -> str:
-        return f"{self.enum_type.type_annotation()}. {self.extra_description_information}"
+        return (
+            f"{self.enum_type.type_annotation()}. {self.extra_description_information}"
+        )
 
     @property
     def extra_description_information(self):
@@ -197,18 +206,19 @@ class HiddenModelEnumSchema(EnumSchema):
         if len(possible_values) == 2:
             possible_values_str = " or ".join(possible_values)
         else:
-            possible_values_str = ", ".join(
-                possible_values[: len(possible_values) - 1]
-            ) + f", and {possible_values[-1]}"
+            possible_values_str = (
+                ", ".join(possible_values[: len(possible_values) - 1])
+                + f", and {possible_values[-1]}"
+            )
 
         return "Known values are: {}.".format(possible_values_str)
 
     @property
     def docstring_type(self) -> str:
-        """The python type used for RST syntax input and type annotation.
-        """
+        """The python type used for RST syntax input and type annotation."""
         return self.enum_type.type_annotation()
 
+
 def get_enum_schema(code_model) -> Type[EnumSchema]:
     if code_model.options["models_mode"]:
         return EnumSchema

package/autorest/codegen/models/imports.py

@@ -4,7 +4,8 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum
-from typing import Dict, List, Optional, Tuple, Union, Set
+from typing import Dict, List, Optional, Tuple, Union, Set, Mapping
+
 
 class ImportType(str, Enum):
     STDLIB = "stdlib"
@@ -12,11 +13,13 @@ class ImportType(str, Enum):
     AZURECORE = "azurecore"
     LOCAL = "local"
 
+
 class TypingSection(str, Enum):
     REGULAR = "regular"  # this import is always a typing import
     CONDITIONAL = "conditional"  # is a typing import when we're dealing with files that py2 will use, else regular
     TYPING = "typing"  # never a typing import
 
+
 class ImportModel:
     def __init__(
         self,
@@ -36,11 +39,11 @@ class ImportModel:
     def __eq__(self, other):
         try:
             return (
-                self.typing_section == other.typing_section and
-                self.import_type == other.import_type and
-                self.module_name == other.module_name and
-                self.submodule_name == other.submodule_name and
-                self.alias == other.alias
+                self.typing_section == other.typing_section
+                and self.import_type == other.import_type
+                and self.module_name == other.module_name
+                and self.submodule_name == other.submodule_name
+                and self.alias == other.alias
             )
         except AttributeError:
             return False
@@ -52,18 +55,32 @@ class ImportModel:
                 retval += hash(getattr(self, attr))
         return retval
 
-class FileImport:
+
+class TypeDefinition:
     def __init__(
         self,
-        imports: List[ImportModel] = None
-    ) -> None:
+        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:
+    def __init__(self, imports: List[ImportModel] = None) -> None:
         self.imports = imports or []
         # has sync and async type definitions
-        self.type_definitions: Dict[str, Tuple[str, str]] = {}
+        self.type_definitions: Dict[str, TypeDefinition] = {}
 
     def _append_import(self, import_model: ImportModel) -> None:
         if not any(
-            i for i in self.imports
+            i
+            for i in self.imports
             if all(
                 getattr(i, attr) == getattr(import_model, attr)
                 for attr in dir(i)
@@ -72,7 +89,9 @@ class FileImport:
         ):
             self.imports.append(import_model)
 
-    def get_imports_from_section(self, typing_section: TypingSection) -> List[ImportModel]:
+    def get_imports_from_section(
+        self, typing_section: TypingSection
+    ) -> List[ImportModel]:
         return [i for i in self.imports if i.typing_section == typing_section]
 
     def add_submodule_import(
@@ -83,15 +102,16 @@ class FileImport:
         typing_section: TypingSection = TypingSection.REGULAR,
         alias: Optional[str] = None,
     ) -> None:
-        """Add an import to this import block.
-        """
-        self._append_import(ImportModel(
-            typing_section=typing_section,
-            import_type=import_type,
-            module_name=module_name,
-            submodule_name=submodule_name,
-            alias=alias,
-        ))
+        """Add an import to this import block."""
+        self._append_import(
+            ImportModel(
+                typing_section=typing_section,
+                import_type=import_type,
+                module_name=module_name,
+                submodule_name=submodule_name,
+                alias=alias,
+            )
+        )
 
     def add_import(
         self,
@@ -101,16 +121,25 @@ class FileImport:
         alias: Optional[str] = None,
     ) -> None:
         # Implementation detail: a regular import is just a "from" with no from
-        self._append_import(ImportModel(
-            typing_section=typing_section,
-            import_type=import_type,
-            module_name=module_name,
-            alias=alias,
-        ))
+        self._append_import(
+            ImportModel(
+                typing_section=typing_section,
+                import_type=import_type,
+                module_name=module_name,
+                alias=alias,
+            )
+        )
 
-    def define_mypy_type(self, type_name: str, type_value: str, async_type_value: Optional[str] = None):
-        self.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        self.type_definitions[type_name] = (type_value, async_type_value or type_value)
+    def define_mypy_type(
+        self,
+        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
+        )
 
     def merge(self, file_import: "FileImport") -> None:
         """Merge the given file import format."""
@@ -118,23 +147,23 @@ class FileImport:
             self._append_import(i)
         self.type_definitions.update(file_import.type_definitions)
 
-    def to_dict(self) -> Dict[
+    def to_dict(
+        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]]]]]],
     ]:
         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]]]]]],
         ] = dict()
         for i in self.imports:
             name_import: Optional[Union[str, Tuple[str, str]]] = None
             if i.submodule_name:
-                name_import = (i.submodule_name, i.alias) if i.alias else i.submodule_name
-            retval.setdefault(
-                    i.typing_section, dict()
-                ).setdefault(
-                    i.import_type, dict()
-                ).setdefault(
-                    i.module_name, set()
-                ).add(name_import)
+                name_import = (
+                    (i.submodule_name, i.alias) if i.alias else i.submodule_name
+                )
+            retval.setdefault(i.typing_section, dict()).setdefault(
+                i.import_type, dict()
+            ).setdefault(i.module_name, set()).add(name_import)
         return retval

package/autorest/codegen/models/list_schema.py

@@ -3,23 +3,26 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union, TYPE_CHECKING
 from .base_schema import BaseSchema
 from .imports import FileImport, ImportType, TypingSection
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 
 class ListSchema(BaseSchema):
     def __init__(
         self,
-        namespace: str,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         element_type: BaseSchema,
         *,
         max_items: Optional[int] = None,
         min_items: Optional[int] = None,
         unique_items: Optional[int] = None,
     ) -> None:
-        super(ListSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.element_type = element_type
         self.max_items = max_items
         self.min_items = min_items
@@ -32,7 +35,9 @@ class ListSchema(BaseSchema):
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
         if self.element_type.type_annotation() == "ET.Element":
             # this means we're version tolerant XML, we just return the XML element
-            return self.element_type.type_annotation(is_operation_file=is_operation_file)
+            return self.element_type.type_annotation(
+                is_operation_file=is_operation_file
+            )
         return f"List[{self.element_type.type_annotation(is_operation_file=is_operation_file)}]"
 
     @property
@@ -63,14 +68,14 @@ class ListSchema(BaseSchema):
 
     @property
     def has_xml_serialization_ctxt(self) -> bool:
-        return super().has_xml_serialization_ctxt or self.element_type.has_xml_serialization_ctxt
+        return (
+            super().has_xml_serialization_ctxt
+            or self.element_type.has_xml_serialization_ctxt
+        )
 
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         return [self.element_type.get_json_template_representation(**kwargs)]
 
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        return [self.element_type.get_files_and_data_template_representation(**kwargs)]
-
     def xml_serialization_ctxt(self) -> Optional[str]:
         attrs_list = []
         base_xml_map = super().xml_serialization_ctxt()
@@ -93,17 +98,19 @@ class ListSchema(BaseSchema):
         return ", ".join(attrs_list)
 
     @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs) -> "ListSchema":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "ListSchema":
         # TODO: for items, if the type is a primitive is it listed in type instead of $ref?
         element_schema = yaml_data["elementType"]
 
         from . import build_schema  # pylint: disable=import-outside-toplevel
 
-        element_type = build_schema(yaml_data=element_schema, **kwargs)
+        element_type = build_schema(yaml_data=element_schema, code_model=code_model)
 
         return cls(
-            namespace=namespace,
             yaml_data=yaml_data,
+            code_model=code_model,
             element_type=element_type,
             max_items=yaml_data.get("maxItems"),
             min_items=yaml_data.get("minItems"),
@@ -112,8 +119,13 @@ class ListSchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        if not self.element_type.type_annotation(is_operation_file=True) == "ET.Element":
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if (
+            not self.element_type.type_annotation(is_operation_file=True)
+            == "ET.Element"
+        ):
+            file_import.add_submodule_import(
+                "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
         file_import.merge(self.element_type.imports())
         return file_import