@autorest/python 6.3.2 → 6.4.1

package/autorest/black/__init__.py

@@ -13,7 +13,7 @@ from black.report import NothingChanged
 from .. import Plugin, PluginAutorest
 from .._utils import parse_args
 
-logging.getLogger("blib2to3").setLevel(logging.ERROR)
+_LOGGER = logging.getLogger("blib2to3")
 
 _BLACK_MODE = black.Mode()  # pyright: ignore [reportPrivateImportUsage]
 _BLACK_MODE.line_length = 120
@@ -40,8 +40,16 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
         return True
 
     def format_file(self, file: Path) -> None:
-        file_content = self.read_file(file)
-        if not file.suffix == ".py":
+        try:
+            file_content = self.read_file(file)
+        except Exception as e:  # pylint: disable=broad-except
+            if file.suffix != ".py":
+                _LOGGER.warning(
+                    "Can not read file %s, not blacking this file", file.name
+                )
+                return
+            raise e  # still want to raise if we fail reading a py file
+        if file.suffix != ".py":
             self.write_file(file, file_content)
             return
         try:

package/autorest/codegen/__init__.py

@@ -164,6 +164,7 @@ class CodeGenerator(Plugin):
                 low_level_client or version_tolerant,
             ),
             "generate_sample": self.options.get("generate-sample", False),
+            "default_api_version": self.options.get("default-api-version"),
         }
 
         if options["builders_visibility"] is None:
@@ -276,6 +277,7 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
                 "default-optional-constants-to-none"
             ),
             "generate-sample": self._autorestapi.get_boolean_value("generate-sample"),
+            "default-api-version": self._autorestapi.get_value("default-api-version"),
         }
         return {k: v for k, v in options.items() if v is not None}
 

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
 
@@ -125,7 +126,6 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             self.code_model.options["show_operations"]
             and self.code_model.has_operations
             and self.code_model.options["generate_sample"]
-            and not self.code_model.options["multiapi"]
         ):
             self._serialize_and_write_sample(env, namespace_path)
 
@@ -193,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)
@@ -549,6 +554,12 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         for client in self.code_model.clients:
             for op_group in client.operation_groups:
                 for operation in op_group.operations:
+                    if (
+                        self.code_model.options["multiapi"]
+                        and operation.api_versions[0]
+                        != self.code_model.options["default_api_version"]
+                    ):
+                        continue
                     samples = operation.yaml_data["samples"]
                     if not samples or operation.name.startswith("_"):
                         continue

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.3.2",
+  "version": "6.4.1",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {

package/requirements.txt

@@ -6,7 +6,7 @@ json-rpc==1.14.0
 m2r2==0.3.3
 MarkupSafe==2.1.2
 mistune==0.8.4
-pathspec==0.10.3
+pathspec==0.11.0
 platformdirs==2.6.2
 PyYAML==6.0
 tomli==2.0.1