@autorest/python 6.4.0 → 6.4.1

package/autorest/codegen/models/code_model.py

@@ -8,6 +8,7 @@ from typing import List, Dict, Any, Set, Union
 from .base import BaseType
 from .enum_type import EnumType
 from .model_type import ModelType
+from .combined_type import CombinedType
 from .client import Client
 from .request_builder import RequestBuilder, OverloadedRequestBuilder
 from .constant_type import ConstantType
@@ -72,6 +73,9 @@ class CodeModel:  # pylint: disable=too-many-public-methods
         if self.options["models_mode"] and self.model_types:
             self.sort_model_types()
         self.is_subnamespace = is_subnamespace
+        self.named_unions: List[CombinedType] = [
+            t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
+        ]
 
     @property
     def has_operations(self) -> bool:

package/autorest/codegen/models/combined_type.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
 import re
-from autorest.codegen.models.imports import FileImport, ImportType
+from autorest.codegen.models.imports import FileImport, ImportType, TypingSection
 from .base import BaseType
 from .model_type import JSONModelType
 
@@ -29,6 +29,7 @@ class CombinedType(BaseType):
     ) -> None:
         super().__init__(yaml_data, code_model)
         self.types = types  # the types that this type is combining
+        self.name = yaml_data.get("name")
 
     @property
     def serialization_type(self) -> str:
@@ -62,11 +63,16 @@ class CombinedType(BaseType):
         return " or ".join(t.docstring_type(**kwargs) for t in self.types)
 
     def type_annotation(self, **kwargs: Any) -> str:
+        if self.name:
+            ret = f"_types.{self.name}"
+            return ret if kwargs.get("is_operation_file") else f'"{ret}"'
+        return self.type_definition(**kwargs)
+
+    def type_definition(self, **kwargs: Any) -> str:
         """The python type used for type annotation
 
         Special case for enum, for instance: Union[str, "EnumName"]
         """
-        kwargs["is_operation_file"] = True
         inside_types = [type.type_annotation(**kwargs) for type in self.types]
 
         # If the inside types has been a Union, peel first and then re-union
@@ -96,6 +102,14 @@ class CombinedType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
+        if self.name and not kwargs.get("is_types_file"):
+            file_import.add_submodule_import(
+                kwargs.pop("relative_path"),
+                "_types",
+                ImportType.LOCAL,
+                TypingSection.TYPING,
+            )
+            return file_import
         for type in self.types:
             file_import.merge(type.imports(**kwargs))
         file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)

package/autorest/codegen/models/enum_type.py

@@ -194,6 +194,12 @@ class EnumType(BaseType):
         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"
+                relative_path,
+                "models",
+                ImportType.LOCAL,
+                alias="_models",
+                typing_section=TypingSection.TYPING
+                if kwargs.get("model_typing")
+                else TypingSection.REGULAR,
             )
         return file_import

package/autorest/codegen/models/model_type.py

@@ -303,9 +303,15 @@ class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
         file_import = super().imports(**kwargs)
         relative_path = kwargs.pop("relative_path", None)
         if relative_path:
-            # add import for models in operations file
+            # add import for models in operations or _types file
             file_import.add_submodule_import(
-                relative_path, "models", ImportType.LOCAL, alias="_models"
+                relative_path,
+                "models",
+                ImportType.LOCAL,
+                alias="_models",
+                typing_section=TypingSection.TYPING
+                if kwargs.get("model_typing")
+                else TypingSection.REGULAR,
             )
         return file_import
 

package/autorest/codegen/models/parameter.py

@@ -17,7 +17,7 @@ from typing import (
     Generic,
 )
 
-from .imports import FileImport, ImportType
+from .imports import FileImport, ImportType, TypingSection
 from .base import BaseModel
 from .base import BaseType
 from .constant_type import ConstantType
@@ -165,6 +165,13 @@ class _ParameterBase(
                 "api_version_validation",
                 ImportType.LOCAL,
             )
+        if isinstance(self.type, CombinedType) and self.type.name:
+            file_import.add_submodule_import(
+                "..",
+                "_types",
+                ImportType.LOCAL,
+                TypingSection.TYPING,
+            )
         return file_import
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:

package/autorest/codegen/models/property.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, Optional, TYPE_CHECKING, List
 from .base import BaseModel
 from .constant_type import ConstantType
 from .base import BaseType
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport, ImportType
 from .utils import add_to_description, add_to_pylint_disable
 
 if TYPE_CHECKING:
@@ -129,32 +129,12 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         retval.update(self.type.validation or {})
         return retval or None
 
-    @staticmethod
-    def contain_model_type(t: BaseType) -> bool:
-        from . import ListType, DictionaryType, ModelType
-
-        if isinstance(t, ModelType):
-            return True
-        if isinstance(t, ListType):
-            return Property.contain_model_type(t.element_type)
-        if isinstance(t, DictionaryType):
-            return Property.contain_model_type(t.element_type)
-        if isinstance(t, ConstantType):
-            return Property.contain_model_type(t.value_type)
-        return False
-
     def imports(self, **kwargs) -> FileImport:
-        file_import = self.type.imports(**kwargs, is_operation_file=False)
+        file_import = self.type.imports(
+            **kwargs, is_operation_file=False, relative_path="..", model_typing=True
+        )
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
-        if self.contain_model_type(self.type):
-            file_import.add_submodule_import(
-                "..",
-                "models",
-                ImportType.LOCAL,
-                TypingSection.TYPING,
-                alias="_models",
-            )
         if self.code_model.options["models_mode"] == "dpg":
             file_import.add_submodule_import(
                 ".._model_base",

package/autorest/codegen/models/response.py

@@ -7,11 +7,12 @@ from typing import Dict, Optional, List, Any, TYPE_CHECKING, Union
 
 from .base import BaseModel
 from .base import BaseType
-from .imports import FileImport, ImportType
+from .imports import FileImport, ImportType, TypingSection
 from .primitive_types import BinaryType, BinaryIteratorType
 from .dictionary_type import DictionaryType
 from .list_type import ListType
 from .model_type import ModelType
+from .combined_type import CombinedType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -105,6 +106,13 @@ class Response(BaseModel):
             file_import.merge(self.type.imports(is_operation_file=True, **kwargs))
         if self.nullable:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+        if isinstance(self.type, CombinedType) and self.type.name:
+            file_import.add_submodule_import(
+                "..",
+                "_types",
+                ImportType.LOCAL,
+                TypingSection.TYPING,
+            )
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:

package/autorest/codegen/serializers/__init__.py

@@ -27,6 +27,7 @@ from .metadata_serializer import MetadataSerializer
 from .request_builders_serializer import RequestBuildersSerializer
 from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
+from .types_serializer import TypesSerializer
 from ..._utils import to_snake_case
 from .utils import extract_sample_name
 
@@ -192,6 +193,11 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                     namespace_path / Path("models.py"),
                     self.read_file(namespace_path / Path("models.py")),
                 )
+        if self.code_model.named_unions:
+            self.write_file(
+                namespace_path / Path("_types.py"),
+                TypesSerializer(code_model=self.code_model, env=env).serialize(),
+            )
 
     def _serialize_and_write_package_files(self, namespace_path: Path) -> None:
         root_of_sdk = self._package_root_folder(namespace_path)

package/autorest/codegen/serializers/client_serializer.py

@@ -110,7 +110,7 @@ class ClientSerializer:
     def initialize_pipeline_client(self, async_mode: bool) -> str:
         pipeline_client_name = self.client.pipeline_class(async_mode)
         return (
-            f"self._client = {pipeline_client_name}(base_url={self.host_variable_name}, "
+            f"self._client: {pipeline_client_name} = {pipeline_client_name}(base_url={self.host_variable_name}, "
             "config=self._config, **kwargs)"
         )
 

package/autorest/codegen/serializers/types_serializer.py

@@ -0,0 +1,38 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from jinja2 import Environment
+from ..models import CodeModel
+from ..models.imports import FileImport, ImportType
+from .import_serializer import FileImportSerializer
+
+
+class TypesSerializer:
+    def __init__(self, code_model: CodeModel, env: Environment) -> None:
+        self.code_model = code_model
+        self.env = env
+
+    def imports(self) -> FileImport:
+        file_import = FileImport()
+        if self.code_model.named_unions:
+            file_import.add_submodule_import(
+                "typing",
+                "Union",
+                ImportType.STDLIB,
+            )
+        for nu in self.code_model.named_unions:
+            file_import.merge(
+                nu.imports(relative_path=".", model_typing=True, is_types_file=True)
+            )
+        return file_import
+
+    def serialize(self) -> str:
+        # Generate the models
+        template = self.env.get_template("types.py.jinja2")
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(self.imports()),
+            serializer=self,
+        )

package/autorest/codegen/templates/types.py.jinja2

@@ -0,0 +1,8 @@
+# coding=utf-8
+# pylint: disable=too-many-lines
+{{ code_model.options['license_header'] }}
+
+{{ imports }}
+{% for nu in code_model.named_unions %}
+{{nu.name}} = {{nu.type_definition()}}
+{% endfor %}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.4.0",
+  "version": "6.4.1",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {