@autorest/python 6.1.11 → 6.2.0

package/autorest/codegen/models/client.py

@@ -3,12 +3,18 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, TYPE_CHECKING, TypeVar, Generic, Union
+from typing import Any, Dict, TYPE_CHECKING, TypeVar, Generic, Union, List, Optional
 
 from .base_model import BaseModel
 from .parameter_list import ClientGlobalParameterList, ConfigGlobalParameterList
 from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 from .utils import add_to_pylint_disable
+from .operation_group import OperationGroup
+from .request_builder import (
+    RequestBuilder,
+    OverloadedRequestBuilder,
+)
+from .parameter import Parameter
 
 ParameterListType = TypeVar(
     "ParameterListType",
@@ -16,7 +22,7 @@ ParameterListType = TypeVar(
 )
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class _ClientConfigBase(Generic[ParameterListType], BaseModel):
@@ -25,14 +31,15 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         parameters: ParameterListType,
     ):
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.parameters = parameters
         self.url: str = self.yaml_data[
             "url"
         ]  # the base endpoint of the client. Can be parameterized or not
+        self.legacy_filename: str = self.yaml_data.get("legacyFilename", "client")
 
     @property
     def description(self) -> str:
@@ -46,8 +53,21 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
 class Client(_ClientConfigBase[ClientGlobalParameterList]):
     """Model representing our service client"""
 
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        namespace_model: "NamespaceModel",
+        parameters: ClientGlobalParameterList,
+    ):
+        super().__init__(yaml_data, namespace_model, parameters)
+        self.operation_groups: List[OperationGroup] = []
+        self.request_builders: List[
+            Union[RequestBuilder, OverloadedRequestBuilder]
+        ] = []
+        self.config = Config.from_yaml(yaml_data, self.namespace_model)
+
     def pipeline_class(self, async_mode: bool) -> str:
-        if self.code_model.options["azure_arm"]:
+        if self.namespace_model.options["azure_arm"]:
             if async_mode:
                 return "AsyncARMPipelineClient"
             return "ARMPipelineClient"
@@ -55,12 +75,17 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             return "AsyncPipelineClient"
         return "PipelineClient"
 
+    @property
+    def credential(self) -> Optional[Parameter]:
+        """The credential param, if one exists"""
+        return self.parameters.credential
+
     @property
     def send_request_name(self) -> str:
         """Name of the send request function"""
         return (
             "send_request"
-            if self.code_model.options["show_send_request"]
+            if self.namespace_model.options["show_send_request"]
             else "_send_request"
         )
 
@@ -72,7 +97,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     @property
     def pylint_disable(self) -> str:
         retval = add_to_pylint_disable("", "client-accepts-api-version-keyword")
-        if len(self.code_model.operation_groups) > 6:
+        if len(self.operation_groups) > 6:
             retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
         return retval
 
@@ -80,11 +105,24 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     def filename(self) -> str:
         """Name of the file for the client"""
         if (
-            self.code_model.options["version_tolerant"]
-            or self.code_model.options["low_level_client"]
+            self.namespace_model.options["version_tolerant"]
+            or self.namespace_model.options["low_level_client"]
         ):
             return "_client"
-        return f"_{self.code_model.module_name}"
+        return f"_{self.legacy_filename}"
+
+    def lookup_request_builder(
+        self, request_builder_id: int
+    ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
+        """Find the request builder based off of id"""
+        try:
+            return next(
+                rb
+                for rb in self.request_builders
+                if id(rb.yaml_data) == request_builder_id
+            )
+        except StopIteration:
+            raise KeyError(f"No request builder with id {request_builder_id} found.")
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
@@ -92,7 +130,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if self.code_model.options["azure_arm"]:
+        if self.namespace_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core", self.pipeline_class(async_mode), ImportType.AZURECORE
             )
@@ -105,11 +143,11 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             file_import.merge(gp.imports(async_mode))
         file_import.add_submodule_import(
             "._configuration",
-            f"{self.code_model.client.name}Configuration",
+            f"{self.name}Configuration",
             ImportType.LOCAL,
         )
         file_import.add_msrest_import(
-            self.code_model,
+            self.namespace_model,
             ".." if async_mode else ".",
             MsrestImportType.SerializerDeserializer,
             TypingSection.REGULAR,
@@ -117,6 +155,58 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
 
         return file_import
 
+    @property
+    def has_mixin(self) -> bool:
+        """Do we want a mixin ABC class for typing purposes?"""
+        return any(o for o in self.operation_groups if o.is_mixin)
+
+    @property
+    def need_format_url(self) -> bool:
+        """Whether we need to format urls. If so, we need to vendor core."""
+        return any(rq for rq in self.request_builders if rq.parameters.path)
+
+    @property
+    def has_lro_operations(self) -> bool:
+        """Are there any LRO operations in this SDK?"""
+        return any(
+            [
+                operation.operation_type in ("lro", "lropaging")
+                for operation_group in self.operation_groups
+                for operation in operation_group.operations
+            ]
+        )
+
+    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
+        type of the LRO operation
+        """
+        for operation_group in self.operation_groups:
+            i = 0
+            while i < len(operation_group.operations):
+                operation = operation_group.operations[i]
+                if operation.operation_type in ("lro", "lropaging"):
+                    operation_group.operations.insert(i, operation.initial_operation)  # type: ignore
+                    i += 1
+                i += 1
+
+    @property
+    def need_request_converter(self) -> bool:
+        """
+        Whether we need to convert our created azure.core.rest.HttpRequests to
+        azure.core.pipeline.transport.HttpRequests
+        """
+        return (
+            self.namespace_model.options["show_operations"]
+            and bool(self.request_builders)
+            and not self.namespace_model.options["version_tolerant"]
+        )
+
+    @property
+    def has_abstract_operations(self) -> bool:
+        """Whether there is abstract operation in any operation group."""
+        return any(og.has_abstract_operations for og in self.operation_groups)
+
     def imports(self, async_mode: bool) -> FileImport:
         file_import = self._imports_shared(async_mode)
         if async_mode:
@@ -140,20 +230,20 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ImportType.AZURECORE,
             TypingSection.CONDITIONAL,
         )
-        for og in self.code_model.operation_groups:
+        for og in self.operation_groups:
             file_import.add_submodule_import(
-                f".{self.code_model.operations_folder_name}",
+                f".{self.namespace_model.operations_folder_name}",
                 og.class_name,
                 ImportType.LOCAL,
             )
 
         if (
-            self.code_model.model_types
-            and self.code_model.options["models_mode"] == "msrest"
+            self.namespace_model.model_types
+            and self.namespace_model.options["models_mode"] == "msrest"
         ):
             path_to_models = ".." if async_mode else "."
-            if len(self.code_model.model_types) != len(
-                self.code_model.public_model_types
+            if len(self.namespace_model.model_types) != len(
+                self.namespace_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
@@ -161,7 +251,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.code_model.models_filename,
+                    self.namespace_model.models_filename,
                     ImportType.LOCAL,
                     alias="models",
                 )
@@ -169,7 +259,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 file_import.add_submodule_import(
                     path_to_models, "models", ImportType.LOCAL
                 )
-        elif self.code_model.options["models_mode"] == "msrest":
+        elif self.namespace_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(
@@ -184,9 +274,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
         try:
-            mixin_operation = next(
-                og for og in self.code_model.operation_groups if og.is_mixin
-            )
+            mixin_operation = next(og for og in self.operation_groups if og.is_mixin)
             file_import.add_submodule_import(
                 "._operations_mixin", mixin_operation.class_name, ImportType.LOCAL
             )
@@ -206,11 +294,13 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Client":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> "Client":
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            parameters=ClientGlobalParameterList.from_yaml(yaml_data, code_model),
+            namespace_model=namespace_model,
+            parameters=ClientGlobalParameterList.from_yaml(yaml_data, namespace_model),
         )
 
 
@@ -224,6 +314,13 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
             "Note that all parameters used to create this instance are saved as instance attributes."
         )
 
+    @property
+    def sdk_moniker(self) -> str:
+        package_name = self.namespace_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()
+
     @property
     def name(self) -> str:
         return f"{super().name}Configuration"
@@ -239,13 +336,13 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if self.code_model.options["package_version"]:
+        if self.namespace_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.code_model.options["azure_arm"]:
+        if self.namespace_model.options["azure_arm"]:
             policy = (
                 "AsyncARMChallengeAuthenticationPolicy"
                 if async_mode
@@ -260,9 +357,11 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Config":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> "Config":
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            parameters=ConfigGlobalParameterList.from_yaml(yaml_data, code_model),
+            namespace_model=namespace_model,
+            parameters=ConfigGlobalParameterList.from_yaml(yaml_data, namespace_model),
         )

package/autorest/codegen/models/code_model.py

@@ -3,18 +3,21 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Dict, Optional, Any, Set, Union
+from typing import List, Dict, Any, Set, Union
 
 from .base_type import BaseType
 from .enum_type import EnumType
 from .model_type import ModelType
+from .client import Client
+from .request_builder import RequestBuilder, OverloadedRequestBuilder
 from .operation_group import OperationGroup
-from .client import Client, Config
-from .request_builder import OverloadedRequestBuilder, RequestBuilder
-from .parameter import Parameter
 
 
-class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-public-methods
+def _is_legacy(options) -> bool:
+    return not (options["version_tolerant"] or options["low_level_client"])
+
+
+class CodeModel:
     """Holds all of the information we have parsed out of the yaml file. The CodeModel is what gets
     serialized by the serializers.
 
@@ -47,17 +50,34 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     ) -> None:
         self.yaml_data = yaml_data
         self.options = options
+        self.namespace_models: List["NamespaceModel"] = [
+            NamespaceModel(namespace_yaml_data, self.options, namespace)
+            for namespace, namespace_yaml_data in yaml_data.items()
+        ]
+
+    @property
+    def is_legacy(self) -> bool:
+        return _is_legacy(self.options)
+
+    @property
+    def description(self) -> str:
+        return self.namespace_models[0].clients[0].description
+
+
+class NamespaceModel:
+    def __init__(
+        self, yaml_data: Dict[str, Any], options: Dict[str, Any], namespace: str
+    ):
+        self.yaml_data = yaml_data
         self.types_map: Dict[int, BaseType] = {}  # map yaml id to schema
-        self.operation_groups: List[OperationGroup] = []
         self._model_types: List[ModelType] = []
-        self._client: Optional[Client] = None
-        self._config: Optional[Config] = None
-        self.request_builders: List[
-            Union[RequestBuilder, OverloadedRequestBuilder]
-        ] = []
-        self.package_dependency: Dict[str, str] = {}
-        self.namespace: str = yaml_data["client"]["namespace"].lower()
-        self.module_name: str = self.yaml_data["client"]["moduleName"]
+        self.options = options
+        from . import build_type
+
+        for type_yaml in yaml_data.get("types", []):
+            build_type(yaml_data=type_yaml, namespace_model=self)
+        self.clients: List[Client] = []
+        self.namespace = namespace
 
     def lookup_type(self, schema_id: int) -> BaseType:
         """Looks to see if the schema has already been created.
@@ -72,43 +92,24 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         except StopIteration:
             raise KeyError(f"Couldn't find schema with id {schema_id}")
 
-    @property
-    def credential(self) -> Optional[Parameter]:
-        """The credential param, if one exists"""
-        return self.client.parameters.credential
-
-    @property
-    def client(self) -> Client:
-        if not self._client:
-            raise ValueError("You haven't linked the client yet")
-        return self._client
-
-    @client.setter
-    def client(self, val: Client) -> None:
-        self._client = val
-
-    @property
-    def config(self) -> Config:
-        if not self._config:
-            raise ValueError("You haven't linked the config yet")
-        return self._config
-
-    @config.setter
-    def config(self, val: Config) -> None:
-        self._config = val
-
     def lookup_request_builder(
         self, request_builder_id: int
     ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
         """Find the request builder based off of id"""
-        try:
-            return next(
-                rb
-                for rb in self.request_builders
-                if id(rb.yaml_data) == request_builder_id
-            )
-        except StopIteration:
-            raise KeyError(f"No request builder with id {request_builder_id} found.")
+        for client in self.clients:
+            try:
+                return client.lookup_request_builder(request_builder_id)
+            except KeyError:
+                pass
+        raise KeyError(f"No request builder with id {request_builder_id} found.")
+
+    @property
+    def operation_groups(self) -> List[OperationGroup]:
+        return [og for client in self.clients for og in client.operation_groups]
+
+    @property
+    def request_builders(self) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
+        return [rb for client in self.clients for rb in client.request_builders]
 
     @property
     def model_types(self) -> List[ModelType]:
@@ -132,9 +133,11 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         """All of the enums"""
         return [t for t in self.types_map.values() if isinstance(t, EnumType)]
 
-    @staticmethod
     def _sort_model_types_helper(
-        current: ModelType, seen_schema_names: Set[str], seen_schema_yaml_ids: Set[int]
+        self,
+        current: ModelType,
+        seen_schema_names: Set[str],
+        seen_schema_yaml_ids: Set[int],
     ):
         if current.id in seen_schema_yaml_ids:
             return []
@@ -150,7 +153,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                 seen_schema_names.add(current.name)
                 seen_schema_yaml_ids.add(current.id)
                 ancestors = (
-                    CodeModel._sort_model_types_helper(
+                    self._sort_model_types_helper(
                         parent, seen_schema_names, seen_schema_yaml_ids
                     )
                     + ancestors
@@ -170,40 +173,38 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         sorted_object_schemas: List[ModelType] = []
         for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
             sorted_object_schemas.extend(
-                CodeModel._sort_model_types_helper(
+                self._sort_model_types_helper(
                     schema, seen_schema_names, seen_schema_yaml_ids
                 )
             )
         self.model_types = sorted_object_schemas
 
-    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
-        type of the LRO operation
-        """
-        for operation_group in self.operation_groups:
-            i = 0
-            while i < len(operation_group.operations):
-                operation = operation_group.operations[i]
-                if operation.operation_type in ("lro", "lropaging"):
-                    operation_group.operations.insert(i, operation.initial_operation)  # type: ignore
-                    i += 1
-                i += 1
+    @property
+    def is_legacy(self) -> bool:
+        return _is_legacy(self.options)
 
     @property
-    def operations_folder_name(self) -> str:
-        """Get the name of the operations folder that holds operations."""
-        name = "operations"
-        if self.options["version_tolerant"] and not any(
-            og for og in self.operation_groups if not og.is_mixin
-        ):
-            name = f"_{name}"
-        return name
+    def rest_layer_name(self) -> str:
+        """If we have a separate rest layer, what is its name?"""
+        return "rest" if self.options["builders_visibility"] == "public" else "_rest"
 
     @property
-    def has_abstract_operations(self) -> bool:
-        """Whether there is abstract operation in any operation group."""
-        return any(og.has_abstract_operations for og in self.operation_groups)
+    def models_filename(self) -> str:
+        """Get the names of the model file(s)"""
+        if self.is_legacy:
+            return "_models_py3"
+        return "_models"
+
+    @property
+    def client_filename(self) -> str:
+        return self.clients[0].filename
+
+    @property
+    def enums_filename(self) -> str:
+        """The name of the enums file"""
+        if self.is_legacy:
+            return f"_{self.clients[0].legacy_filename}_enums"
+        return "_enums"
 
     def need_vendored_code(self, async_mode: bool) -> bool:
         """Whether we need to vendor code in the _vendor.py file for this SDK"""
@@ -217,58 +218,29 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
 
     @property
     def need_request_converter(self) -> bool:
-        """
-        Whether we need to convert our created azure.core.rest.HttpRequests to
-        azure.core.pipeline.transport.HttpRequests
-        """
-        return (
-            self.options["show_operations"]
-            and bool(self.request_builders)
-            and not self.options["version_tolerant"]
-        )
+        return any(c for c in self.clients if c.need_request_converter)
 
     @property
     def need_format_url(self) -> bool:
-        """Whether we need to format urls. If so, we need to vendor core."""
-        return any(rq for rq in self.request_builders if rq.parameters.path)
+        return any(c for c in self.clients if c.need_format_url)
 
     @property
     def need_mixin_abc(self) -> bool:
-        """Do we want a mixin ABC class for typing purposes?"""
-        return any(o for o in self.operation_groups if o.is_mixin)
+        return any(c for c in self.clients if c.has_mixin)
 
     @property
-    def has_lro_operations(self) -> bool:
-        """Are there any LRO operations in this SDK?"""
-        return any(
-            [
-                operation.operation_type in ("lro", "lropaging")
-                for operation_group in self.operation_groups
-                for operation in operation_group.operations
-            ]
-        )
-
-    @property
-    def models_filename(self) -> str:
-        """Get the names of the model file(s)"""
-        if self.is_legacy:
-            return "_models_py3"
-        return "_models"
-
-    @property
-    def enums_filename(self) -> str:
-        """The name of the enums file"""
-        if self.is_legacy:
-            return f"_{self.module_name}_enums"
-        return "_enums"
-
-    @property
-    def is_legacy(self) -> bool:
-        return not (
-            self.options["version_tolerant"] or self.options["low_level_client"]
-        )
+    def has_abstract_operations(self) -> bool:
+        return any(c for c in self.clients if c.has_abstract_operations)
 
     @property
-    def rest_layer_name(self) -> str:
-        """If we have a separate rest layer, what is its name?"""
-        return "rest" if self.options["builders_visibility"] == "public" else "_rest"
+    def operations_folder_name(self) -> str:
+        """Get the name of the operations folder that holds operations."""
+        name = "operations"
+        if self.options["version_tolerant"] and not any(
+            og
+            for client in self.clients
+            for og in client.operation_groups
+            if not og.is_mixin
+        ):
+            name = f"_{name}"
+        return name

package/autorest/codegen/models/combined_type.py

@@ -9,7 +9,7 @@ from autorest.codegen.models.imports import FileImport, ImportType
 from .base_type import BaseType
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
     from .model_type import ModelType
 
 
@@ -21,9 +21,12 @@ class CombinedType(BaseType):
     """
 
     def __init__(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel", types: List[BaseType]
+        self,
+        yaml_data: Dict[str, Any],
+        namespace_model: "NamespaceModel",
+        types: List[BaseType],
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.types = types  # the types that this type is combining
 
     @property
@@ -102,12 +105,12 @@ class CombinedType(BaseType):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "BaseType":
         from . import build_type
 
         return cls(
             yaml_data,
-            code_model,
-            [build_type(t, code_model) for t in yaml_data["types"]],
+            namespace_model,
+            [build_type(t, namespace_model) for t in yaml_data["types"]],
         )