@autorest/python 5.16.0 → 5.19.0

package/autorest/codegen/models/client.py

@@ -3,26 +3,48 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Optional, TYPE_CHECKING
-from .parameter_list import GlobalParameterList
-from .imports import FileImport, ImportType, TypingSection
+from typing import Any, Dict, TYPE_CHECKING, TypeVar, Generic, Union
+
+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
+
+ParameterListType = TypeVar(
+    "ParameterListType",
+    bound=Union[ClientGlobalParameterList, ConfigGlobalParameterList],
+)
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
 
-class Client:
-    """A service client."""
+class _ClientConfigBase(Generic[ParameterListType], BaseModel):
+    """The service client base. Shared across our Client and Config type"""
 
-    def __init__(self, code_model: "CodeModel", parameters: GlobalParameterList):
-        self.code_model = code_model
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        parameters: ParameterListType,
+    ):
+        super().__init__(yaml_data, code_model)
         self.parameters = parameters
-        self.parameterized_host_template: Optional[str] = None
-        self._config_parameters = parameters
+        self.url: str = self.yaml_data[
+            "url"
+        ]  # the base endpoint of the client. Can be parameterized or not
 
     @property
-    def has_parameterized_host(self) -> bool:
-        return bool(self.parameterized_host_template)
+    def description(self) -> str:
+        return self.yaml_data["description"]
+
+    @property
+    def name(self) -> str:
+        return self.yaml_data["name"]
+
+
+class Client(_ClientConfigBase[ClientGlobalParameterList]):
+    """Model representing our service client"""
 
     def pipeline_class(self, async_mode: bool) -> str:
         if self.code_model.options["azure_arm"]:
@@ -33,31 +55,43 @@ class Client:
             return "AsyncPipelineClient"
         return "PipelineClient"
 
+    @property
+    def send_request_name(self) -> str:
+        """Name of the send request function"""
+        return (
+            "send_request"
+            if self.code_model.options["show_send_request"]
+            else "_send_request"
+        )
+
+    @property
+    def has_parameterized_host(self) -> bool:
+        """Whether the base url is parameterized or not"""
+        return not any(p for p in self.parameters if p.is_host)
+
+    @property
+    def pylint_disable(self) -> str:
+        retval = add_to_pylint_disable("", "client-accepts-api-version-keyword")
+        if len(self.code_model.operation_groups) > 6:
+            retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
+        return retval
+
+    @property
+    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"]
+        ):
+            return "_client"
+        return f"_{self.code_model.module_name}"
+
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
 
-        file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
-        file_import.add_submodule_import(
-            "msrest", "Deserializer", ImportType.THIRDPARTY
-        )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-
-        any_optional_gp = any(not gp.required for gp in self.parameters)
-
-        legacy = not any(
-            g
-            for g in ["low_level_client", "version_tolerant"]
-            if g in self.code_model.options
-        )
-        if any_optional_gp or (
-            legacy and self.code_model.service_client.parameters.host
-        ):
-            file_import.add_submodule_import(
-                "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
-            )
-
         if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core", self.pipeline_class(async_mode), ImportType.AZURECORE
@@ -67,14 +101,21 @@ class Client:
                 "azure.core", self.pipeline_class(async_mode), ImportType.AZURECORE
             )
 
-        for gp in self.code_model.global_parameters:
-            file_import.merge(gp.imports())
+        for gp in self.parameters:
+            file_import.merge(gp.imports(async_mode))
         file_import.add_submodule_import(
             "._configuration",
-            f"{self.code_model.class_name}Configuration",
+            f"{self.code_model.client.name}Configuration",
             ImportType.LOCAL,
         )
 
+        file_import.add_msrest_import(
+            self.code_model,
+            ".." if async_mode else ".",
+            MsrestImportType.SerializerDeserializer,
+            TypingSection.REGULAR,
+        )
+
         return file_import
 
     def imports(self, async_mode: bool) -> FileImport:
@@ -107,9 +148,25 @@ class Client:
                 ImportType.LOCAL,
             )
 
-        if self.code_model.sorted_schemas:
+        if self.code_model.model_types and self.code_model.options["models_mode"]:
             path_to_models = ".." if async_mode else "."
-            file_import.add_submodule_import(path_to_models, "models", ImportType.LOCAL)
+            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
+
+                # Also in this case, we're in version tolerant, so python3 only is true
+                file_import.add_submodule_import(
+                    f"{path_to_models}models",
+                    f"{self.code_model.get_models_filename(is_python3_file=True)}",
+                    ImportType.LOCAL,
+                    alias="models",
+                )
+            else:
+                file_import.add_submodule_import(
+                    path_to_models, "models", ImportType.LOCAL
+                )
         else:
             # 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
@@ -121,34 +178,89 @@ class Client:
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
         file_import = self._imports_shared(async_mode)
+        file_import.add_submodule_import(
+            "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
         try:
             mixin_operation = next(
-                og
-                for og in self.code_model.operation_groups
-                if og.is_empty_operation_group
+                og for og in self.code_model.operation_groups if og.is_mixin
             )
             file_import.add_submodule_import(
                 "._operations_mixin", mixin_operation.class_name, ImportType.LOCAL
             )
         except StopIteration:
             pass
+        file_import.add_submodule_import(
+            "azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.profiles", "ProfileDefinition", import_type=ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.profiles.multiapiclient",
+            "MultiApiClientMixin",
+            import_type=ImportType.AZURECORE,
+        )
         return file_import
 
-    def send_request_signature(self, is_python3_file: bool) -> List[str]:
-        request_signature = [
-            "request: HttpRequest,"
-            if is_python3_file
-            else "request,  # type: HttpRequest"
-        ]
-        return request_signature + self.parameters.method_signature_kwargs(
-            is_python3_file
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Client":
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            parameters=ClientGlobalParameterList.from_yaml(yaml_data, code_model),
         )
 
+
+class Config(_ClientConfigBase[ConfigGlobalParameterList]):
+    """Model representing our Config type."""
+
     @property
-    def filename(self) -> str:
-        if (
-            self.code_model.options["version_tolerant"]
-            or self.code_model.options["low_level_client"]
-        ):
-            return "_client"
-        return f"_{self.code_model.module_name}"
+    def description(self) -> str:
+        return (
+            f"Configuration for {self.yaml_data['name']}.\n\n."
+            "Note that all parameters used to create this instance are saved as instance attributes."
+        )
+
+    @property
+    def name(self) -> str:
+        return f"{super().name}Configuration"
+
+    def imports(self, async_mode: bool) -> FileImport:
+        file_import = FileImport()
+        file_import.add_submodule_import(
+            "azure.core.configuration", "Configuration", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.core.pipeline", "policies", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
+        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.code_model.options["azure_arm"]:
+            policy = (
+                "AsyncARMChallengeAuthenticationPolicy"
+                if async_mode
+                else "ARMChallengeAuthenticationPolicy"
+            )
+            file_import.add_submodule_import(
+                "azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.AZURECORE
+            )
+            file_import.add_submodule_import(
+                "azure.mgmt.core.policies", policy, ImportType.AZURECORE
+            )
+        return file_import
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Config":
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            parameters=ConfigGlobalParameterList.from_yaml(yaml_data, code_model),
+        )