@autorest/python 6.2.0 → 6.2.1

package/autorest/codegen/__init__.py

@@ -4,77 +4,18 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any, Union, cast
+from typing import Dict, Any, cast
 from pathlib import Path
 import yaml
 
 
 from .. import Plugin, PluginAutorest
 from .._utils import parse_args
-from .models.client import Client
-from .models.code_model import CodeModel, NamespaceModel
-from .models.request_builder import get_request_builder
-
-from .models.operation_group import OperationGroup
+from .models.code_model import CodeModel
 from .serializers import JinjaSerializer, JinjaSerializerAutorest
 from ._utils import DEFAULT_HEADER_TEXT
 
 
-def _build_convenience_layer(code_model: CodeModel) -> None:
-    for namespace_model in code_model.namespace_models:
-        if namespace_model.options["show_operations"]:
-            for client in namespace_model.clients:
-                client.operation_groups = [
-                    OperationGroup.from_yaml(op_group, namespace_model, client)
-                    for op_group in client.yaml_data.get("operationGroups", [])
-                ]
-        if namespace_model.options["models_mode"] and namespace_model.model_types:
-            namespace_model.sort_model_types()
-
-        if namespace_model.options["show_operations"]:
-            for client in namespace_model.clients:
-                client.format_lro_operations()
-
-
-def _create_code_model(
-    yaml_data: Dict[str, Any], options: Dict[str, Union[str, bool]]
-) -> CodeModel:
-    # Create a code model
-    code_model = CodeModel(yaml_data, options=options)
-    for namespace_model in code_model.namespace_models:
-        namespace_model.clients = [
-            Client.from_yaml(client_yaml_data, namespace_model)
-            for client_yaml_data in namespace_model.yaml_data["clients"]
-        ]
-
-        for client in namespace_model.clients:
-            if not client.yaml_data.get("operationGroups"):
-                continue
-            for og_group in client.yaml_data["operationGroups"]:
-                for operation_yaml in og_group["operations"]:
-                    request_builder = get_request_builder(
-                        operation_yaml,
-                        namespace_model=namespace_model,
-                        client=client,
-                    )
-                    if request_builder.overloads:
-                        client.request_builders.extend(request_builder.overloads)  # type: ignore
-                    client.request_builders.append(request_builder)
-                    if operation_yaml.get("nextOperation"):
-                        # i am a paging operation and i have a next operation.
-                        # Make sure to include my next operation
-                        client.request_builders.append(
-                            get_request_builder(
-                                operation_yaml["nextOperation"],
-                                namespace_model=namespace_model,
-                                client=client,
-                            )
-                        )
-
-    _build_convenience_layer(code_model)
-    return code_model
-
-
 def _validate_code_model_options(options: Dict[str, Any]) -> None:
 
     if options["builders_visibility"] not in ["public", "hidden", "embedded"]:
@@ -242,10 +183,8 @@ class CodeGenerator(Plugin):
         with open(self.options["cadl_file"], "r") as fd:
             return yaml.safe_load(fd.read())
 
-    def get_serializer(self, code_model: CodeModel, namespace_model: NamespaceModel):
-        return JinjaSerializer(
-            code_model, namespace_model, output_folder=self.output_folder
-        )
+    def get_serializer(self, code_model: CodeModel):
+        return JinjaSerializer(code_model, output_folder=self.output_folder)
 
     def process(self) -> bool:
         # List the input file, should be only one
@@ -254,14 +193,11 @@ class CodeGenerator(Plugin):
         yaml_data = self.get_yaml()
 
         if options["azure_arm"]:
-            for namespace in yaml_data.values():
-                self.remove_cloud_errors(namespace)
-
-        code_model = _create_code_model(yaml_data=yaml_data, options=options)
+            self.remove_cloud_errors(yaml_data)
 
-        for namespace_model in code_model.namespace_models:
-            serializer = self.get_serializer(code_model, namespace_model)
-            serializer.serialize()
+        code_model = CodeModel(yaml_data=yaml_data, options=options)
+        serializer = self.get_serializer(code_model)
+        serializer.serialize()
 
         return True
 
@@ -357,11 +293,10 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
         # Parse the received YAML
         return yaml.safe_load(file_content)
 
-    def get_serializer(self, code_model: CodeModel, namespace_model: NamespaceModel):  # type: ignore
+    def get_serializer(self, code_model: CodeModel):  # type: ignore
         return JinjaSerializerAutorest(
             self._autorestapi,
             code_model,
-            namespace_model,
             output_folder=self.output_folder,
         )
 

package/autorest/codegen/models/__init__.py

@@ -5,8 +5,9 @@
 # --------------------------------------------------------------------------
 import logging
 from typing import Any, Dict, Union
-from .base_model import BaseModel
-from .code_model import CodeModel, NamespaceModel
+from .base import BaseModel
+from .base_builder import BaseBuilder
+from .code_model import CodeModel
 from .client import Client
 from .model_type import ModelType
 from .dictionary_type import DictionaryType
@@ -29,7 +30,7 @@ from .primitive_types import (
     UnixTimeType,
 )
 from .enum_type import EnumType
-from .base_type import BaseType
+from .base import BaseType
 from .constant_type import ConstantType
 from .imports import FileImport, ImportType, TypingSection
 from .lro_operation import LROOperation
@@ -58,7 +59,6 @@ from .request_builder import (
     OverloadedRequestBuilder,
     RequestBuilderBase,
 )
-from .base_builder import BaseBuilder
 from .lro_paging_operation import LROPagingOperation
 from .request_builder_parameter import (
     RequestBuilderParameter,
@@ -80,7 +80,6 @@ __all__ = [
     "BaseType",
     "CodeModel",
     "Client",
-    "NamespaceModel",
     "ConstantType",
     "ModelType",
     "DictionaryType",
@@ -148,18 +147,18 @@ TYPE_TO_OBJECT = {
 _LOGGER = logging.getLogger(__name__)
 
 
-def build_type(yaml_data: Dict[str, Any], namespace_model: NamespaceModel) -> BaseType:
+def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
     yaml_id = id(yaml_data)
     try:
-        return namespace_model.lookup_type(yaml_id)
+        return code_model.lookup_type(yaml_id)
     except KeyError:
         # Not created yet, let's create it and add it to the index
         pass
     if yaml_data["type"] == "model":
         # need to special case model to avoid recursion
-        response = ModelType(yaml_data, namespace_model)
-        namespace_model.types_map[yaml_id] = response
-        response.fill_instance_from_yaml(yaml_data, namespace_model)
+        response = ModelType(yaml_data, code_model)
+        code_model.types_map[yaml_id] = response
+        response.fill_instance_from_yaml(yaml_data, code_model)
     else:
         object_type = yaml_data.get("type")
         if object_type not in TYPE_TO_OBJECT:
@@ -168,8 +167,8 @@ def build_type(yaml_data: Dict[str, Any], namespace_model: NamespaceModel) -> Ba
                 yaml_data["type"],
             )
             object_type = "string"
-        response = TYPE_TO_OBJECT[object_type].from_yaml(yaml_data, namespace_model)  # type: ignore
-    namespace_model.types_map[yaml_id] = response
+        response = TYPE_TO_OBJECT[object_type].from_yaml(yaml_data, code_model)  # type: ignore
+    code_model.types_map[yaml_id] = response
     return response
 
 

package/autorest/codegen/models/{base_type.py → base.py}

@@ -3,17 +3,35 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import Any, Dict, TYPE_CHECKING, List, Optional
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
-
-from .base_model import BaseModel
 from .imports import FileImport
 
+
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .model_type import ModelType
 
 
+class BaseModel:
+    """This is the base class for model representations that are based on some YAML data.
+
+    :param yaml_data: the yaml data for this schema
+    :type yaml_data: dict[str, Any]
+    """
+
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        self.yaml_data = yaml_data
+        self.code_model = code_model
+
+    @property
+    def id(self) -> int:
+        return id(self.yaml_data)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}>"
+
+
 class BaseType(BaseModel, ABC):
     """This is the base class for all types.
 
@@ -21,10 +39,8 @@ class BaseType(BaseModel, ABC):
     :type yaml_data: dict[str, Any]
     """
 
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        super().__init__(yaml_data, namespace_model)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data, code_model)
         self.type = yaml_data["type"]  # the type discriminator
         self.api_versions: List[str] = yaml_data.get(
             "apiVersions", []
@@ -32,15 +48,18 @@ class BaseType(BaseModel, ABC):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "BaseType":
-        return cls(yaml_data=yaml_data, namespace_model=namespace_model)
+        return cls(yaml_data=yaml_data, code_model=code_model)
 
     def imports(  # pylint: disable=no-self-use
         self, **kwargs  # pylint: disable=unused-argument
     ) -> FileImport:
         return FileImport()
 
+    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
+        return self.imports(**kwargs)
+
     @property
     def xml_metadata(self) -> Dict[str, Any]:
         """XML metadata for the type, if the type has it."""

package/autorest/codegen/models/base_builder.py

@@ -4,16 +4,16 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
+from typing import List, Dict, Any, Generic, TypeVar, Optional, Union, TYPE_CHECKING
 from abc import abstractmethod
-from typing import Any, Dict, List, Optional, TypeVar, Union, TYPE_CHECKING, Generic
-from .base_model import BaseModel
+
+from .base import BaseModel
 from .parameter_list import (
     ParameterList,
     RequestBuilderParameterList,
     OverloadedRequestBuilderParameterList,
 )
 
-
 ParameterListType = TypeVar(
     "ParameterListType",
     bound=Union[
@@ -22,13 +22,11 @@ ParameterListType = TypeVar(
         OverloadedRequestBuilderParameterList,
     ],
 )
-
-
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
+    from .client import Client
     from .operation import Operation
     from .request_builder import RequestBuilder
-    from .client import Client
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,7 +39,7 @@ class BaseBuilder(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
         name: str,
         parameters: ParameterListType,
@@ -49,7 +47,7 @@ class BaseBuilder(
         overloads=None,
         want_tracing: bool = True,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.client = client
         self.name = name
         self._description: str = yaml_data.get("description", "")
@@ -66,7 +64,7 @@ class BaseBuilder(
         self.api_versions: List[str] = yaml_data["apiVersions"]
         self.added_on: Optional[str] = yaml_data.get("addedOn")
 
-        if namespace_model.options["version_tolerant"] and yaml_data.get("abstract"):
+        if code_model.options["version_tolerant"] and yaml_data.get("abstract"):
             _LOGGER.warning(
                 'Not going to generate operation "%s" because we are unable to generate this '
                 "type of operation right now. "

package/autorest/codegen/models/client.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict, TYPE_CHECKING, TypeVar, Generic, Union, List, Optional
 
-from .base_model import BaseModel
+from .base import BaseModel
 from .parameter_list import ClientGlobalParameterList, ConfigGlobalParameterList
 from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 from .utils import add_to_pylint_disable
@@ -13,8 +13,9 @@ from .operation_group import OperationGroup
 from .request_builder import (
     RequestBuilder,
     OverloadedRequestBuilder,
+    get_request_builder,
 )
-from .parameter import Parameter
+from .parameter import Parameter, ParameterMethodLocation
 
 ParameterListType = TypeVar(
     "ParameterListType",
@@ -22,7 +23,7 @@ ParameterListType = TypeVar(
 )
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 
 class _ClientConfigBase(Generic[ParameterListType], BaseModel):
@@ -31,10 +32,10 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         parameters: ParameterListType,
     ):
-        super().__init__(yaml_data, namespace_model)
+        super().__init__(yaml_data, code_model)
         self.parameters = parameters
         self.url: str = self.yaml_data[
             "url"
@@ -56,18 +57,49 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         parameters: ClientGlobalParameterList,
+        *,
+        is_subclient: bool = False,
     ):
-        super().__init__(yaml_data, namespace_model, parameters)
+        super().__init__(yaml_data, code_model, parameters)
         self.operation_groups: List[OperationGroup] = []
-        self.request_builders: List[
-            Union[RequestBuilder, OverloadedRequestBuilder]
-        ] = []
-        self.config = Config.from_yaml(yaml_data, self.namespace_model)
+        self.config = Config.from_yaml(yaml_data, self.code_model)
+        self.is_subclient = is_subclient
+        self.request_builders = self._build_request_builders()
+        if self.code_model.options["show_operations"]:
+            self.operation_groups = [
+                OperationGroup.from_yaml(op_group, code_model, self)
+                for op_group in self.yaml_data.get("operationGroups", [])
+            ]
+            self.format_lro_operations()
+
+    def _build_request_builders(self):
+        request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]] = []
+        for og_group in self.yaml_data["operationGroups"]:
+            for operation_yaml in og_group["operations"]:
+                request_builder = get_request_builder(
+                    operation_yaml,
+                    code_model=self.code_model,
+                    client=self,
+                )
+                if request_builder.overloads:
+                    request_builders.extend(request_builder.overloads)  # type: ignore
+                request_builders.append(request_builder)
+                if operation_yaml.get("nextOperation"):
+                    # i am a paging operation and i have a next operation.
+                    # Make sure to include my next operation
+                    request_builders.append(
+                        get_request_builder(
+                            operation_yaml["nextOperation"],
+                            code_model=self.code_model,
+                            client=self,
+                        )
+                    )
+        return request_builders
 
     def pipeline_class(self, async_mode: bool) -> str:
-        if self.namespace_model.options["azure_arm"]:
+        if self.code_model.options["azure_arm"]:
             if async_mode:
                 return "AsyncARMPipelineClient"
             return "ARMPipelineClient"
@@ -85,7 +117,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         """Name of the send request function"""
         return (
             "send_request"
-            if self.namespace_model.options["show_send_request"]
+            if self.code_model.options["show_send_request"]
             else "_send_request"
         )
 
@@ -105,8 +137,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     def filename(self) -> str:
         """Name of the file for the client"""
         if (
-            self.namespace_model.options["version_tolerant"]
-            or self.namespace_model.options["low_level_client"]
+            self.code_model.options["version_tolerant"]
+            or self.code_model.options["low_level_client"]
         ):
             return "_client"
         return f"_{self.legacy_filename}"
@@ -130,7 +162,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if self.namespace_model.options["azure_arm"]:
+        if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core", self.pipeline_class(async_mode), ImportType.AZURECORE
             )
@@ -140,6 +172,11 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             )
 
         for gp in self.parameters:
+            if (
+                gp.method_location == ParameterMethodLocation.KWARG
+                and gp not in self.parameters.kwargs_to_pop
+            ):
+                continue
             file_import.merge(gp.imports(async_mode))
         file_import.add_submodule_import(
             "._configuration",
@@ -147,7 +184,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ImportType.LOCAL,
         )
         file_import.add_msrest_import(
-            self.namespace_model,
+            self.code_model,
             ".." if async_mode else ".",
             MsrestImportType.SerializerDeserializer,
             TypingSection.REGULAR,
@@ -176,6 +213,15 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ]
         )
 
+    @property
+    def has_operations(self) -> bool:
+        return any(
+            [
+                bool(operation_group.operations)
+                for operation_group in self.operation_groups
+            ]
+        )
+
     def format_lro_operations(self) -> None:
         """Adds operations and attributes needed for LROs.
         If there are LRO functions in here, will add initial LRO function. Will also set the return
@@ -197,9 +243,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         azure.core.pipeline.transport.HttpRequests
         """
         return (
-            self.namespace_model.options["show_operations"]
+            self.code_model.options["show_operations"]
             and bool(self.request_builders)
-            and not self.namespace_model.options["version_tolerant"]
+            and not self.code_model.options["version_tolerant"]
         )
 
     @property
@@ -232,18 +278,18 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         )
         for og in self.operation_groups:
             file_import.add_submodule_import(
-                f".{self.namespace_model.operations_folder_name}",
+                f".{self.code_model.operations_folder_name}",
                 og.class_name,
                 ImportType.LOCAL,
             )
 
         if (
-            self.namespace_model.model_types
-            and self.namespace_model.options["models_mode"] == "msrest"
+            self.code_model.model_types
+            and self.code_model.options["models_mode"] == "msrest"
         ):
             path_to_models = ".." if async_mode else "."
-            if len(self.namespace_model.model_types) != len(
-                self.namespace_model.public_model_types
+            if len(self.code_model.model_types) != len(
+                self.code_model.public_model_types
             ):
                 # this means we have hidden models. In that case, we import directly from the models
                 # file, not the module, bc we don't expose the hidden models in the models module
@@ -251,7 +297,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 # Also in this case, we're in version tolerant, so python3 only is true
                 file_import.add_submodule_import(
                     f"{path_to_models}models",
-                    self.namespace_model.models_filename,
+                    self.code_model.models_filename,
                     ImportType.LOCAL,
                     alias="models",
                 )
@@ -259,7 +305,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 file_import.add_submodule_import(
                     path_to_models, "models", ImportType.LOCAL
                 )
-        elif self.namespace_model.options["models_mode"] == "msrest":
+        elif self.code_model.options["models_mode"] == "msrest":
             # in this case, we have client_models = {} in the service client, which needs a type annotation
             # this import will always be commented, so will always add it to the typing section
             file_import.add_submodule_import(
@@ -295,12 +341,17 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        *,
+        is_subclient: bool = False,
     ) -> "Client":
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            parameters=ClientGlobalParameterList.from_yaml(yaml_data, namespace_model),
+            code_model=code_model,
+            parameters=ClientGlobalParameterList.from_yaml(yaml_data, code_model),
+            is_subclient=is_subclient,
         )
 
 
@@ -316,7 +367,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
 
     @property
     def sdk_moniker(self) -> str:
-        package_name = self.namespace_model.options["package_name"]
+        package_name = self.code_model.options["package_name"]
         if package_name and package_name.startswith("azure-"):
             package_name = package_name[len("azure-") :]
         return package_name if package_name else self.yaml_data["name"].lower()
@@ -325,7 +376,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
     def name(self) -> str:
         return f"{super().name}Configuration"
 
-    def imports(self, async_mode: bool) -> FileImport:
+    def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
         file_import.add_submodule_import(
             "azure.core.configuration", "Configuration", ImportType.AZURECORE
@@ -336,13 +387,11 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if self.namespace_model.options["package_version"]:
+        if self.code_model.options["package_version"]:
             file_import.add_submodule_import(
                 ".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL
             )
-        for gp in self.parameters:
-            file_import.merge(gp.imports(async_mode=async_mode))
-        if self.namespace_model.options["azure_arm"]:
+        if self.code_model.options["azure_arm"]:
             policy = (
                 "AsyncARMChallengeAuthenticationPolicy"
                 if async_mode
@@ -354,14 +403,36 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
             file_import.add_submodule_import(
                 "azure.mgmt.core.policies", policy, ImportType.AZURECORE
             )
+
+        return file_import
+
+    def imports(self, async_mode: bool) -> FileImport:
+        file_import = self._imports_shared(async_mode)
+        for gp in self.parameters:
+            if (
+                gp.method_location == ParameterMethodLocation.KWARG
+                and gp not in self.parameters.kwargs_to_pop
+            ):
+                continue
+            file_import.merge(gp.imports(async_mode=async_mode))
+        return file_import
+
+    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
+        file_import = self._imports_shared(async_mode)
+        for gp in self.parameters:
+            if (
+                gp.method_location == ParameterMethodLocation.KWARG
+                and gp not in self.parameters.kwargs_to_pop
+                and gp.client_name == "api_version"
+            ):
+                continue
+            file_import.merge(gp.imports_for_multiapi(async_mode=async_mode))
         return file_import
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> "Config":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Config":
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            parameters=ConfigGlobalParameterList.from_yaml(yaml_data, namespace_model),
+            code_model=code_model,
+            parameters=ConfigGlobalParameterList.from_yaml(yaml_data, code_model),
         )