@autorest/python 6.1.11 → 6.2.1

package/autorest/_utils.py

@@ -34,7 +34,8 @@ def to_snake_case(name: str) -> str:
 
         return prefix + match_str
 
-    return re.sub("[A-Z]+", replace_upper_characters, name)
+    result = re.sub("[A-Z]+", replace_upper_characters, name)
+    return result.replace(" ", "_").replace("__", "_").replace("-", "")
 
 
 def parse_args(

package/autorest/codegen/__init__.py

@@ -4,38 +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, Config
 from .models.code_model import CodeModel
-from .models import build_type
-from .models.request_builder import get_request_builder
-from .models.operation_group import OperationGroup
 from .serializers import JinjaSerializer, JinjaSerializerAutorest
 from ._utils import DEFAULT_HEADER_TEXT
 
 
-def _build_convenience_layer(yaml_data: Dict[str, Any], code_model: CodeModel) -> None:
-    # Create operations
-    if code_model.options["show_operations"] and yaml_data.get("operationGroups"):
-        code_model.operation_groups = [
-            OperationGroup.from_yaml(op_group, code_model)
-            for op_group in yaml_data["operationGroups"]
-        ]
-    if yaml_data.get("types"):
-        if code_model.options["models_mode"]:
-            code_model.sort_model_types()
-
-    if code_model.options["show_operations"]:
-        # LRO operation
-        code_model.format_lro_operations()
-
-
 def _validate_code_model_options(options: Dict[str, Any]) -> None:
 
     if options["builders_visibility"] not in ["public", "hidden", "embedded"]:
@@ -97,21 +77,22 @@ _LOGGER = logging.getLogger(__name__)
 class CodeGenerator(Plugin):
     @staticmethod
     def remove_cloud_errors(yaml_data: Dict[str, Any]) -> None:
-        for group in yaml_data["operationGroups"]:
-            for operation in group["operations"]:
-                if not operation.get("exceptions"):
-                    continue
-                i = 0
-                while i < len(operation["exceptions"]):
-                    exception = operation["exceptions"][i]
-                    if (
-                        exception.get("schema")
-                        and exception["schema"]["language"]["default"]["name"]
-                        == "CloudError"
-                    ):
-                        del operation["exceptions"][i]
-                        i -= 1
-                    i += 1
+        for client in yaml_data["clients"]:
+            for group in client["operationGroups"]:
+                for operation in group["operations"]:
+                    if not operation.get("exceptions"):
+                        continue
+                    i = 0
+                    while i < len(operation["exceptions"]):
+                        exception = operation["exceptions"][i]
+                        if (
+                            exception.get("schema")
+                            and exception["schema"]["language"]["default"]["name"]
+                            == "CloudError"
+                        ):
+                            del operation["exceptions"][i]
+                            i -= 1
+                        i += 1
         if yaml_data.get("schemas") and yaml_data["schemas"].get("objects"):
             for i in range(len(yaml_data["schemas"]["objects"])):
                 obj_schema = yaml_data["schemas"]["objects"][i]
@@ -119,48 +100,6 @@ class CodeGenerator(Plugin):
                     del yaml_data["schemas"]["objects"][i]
                     break
 
-    @staticmethod
-    def _build_package_dependency() -> Dict[str, str]:
-        return {
-            "dependency_azure_mgmt_core": "azure-mgmt-core<2.0.0,>=1.3.2",
-            "dependency_azure_core": "azure-core<2.0.0,>=1.24.0",
-            "dependency_msrest": "msrest>=0.7.1",
-        }
-
-    def _create_code_model(
-        self, yaml_data: Dict[str, Any], options: Dict[str, Union[str, bool]]
-    ) -> CodeModel:
-        # Create a code model
-
-        code_model = CodeModel(yaml_data, options=options)
-        for type_yaml in yaml_data.get("types", []):
-            build_type(yaml_data=type_yaml, code_model=code_model)
-
-        code_model.client = Client.from_yaml(yaml_data["client"], code_model)
-        code_model.config = Config.from_yaml(yaml_data["client"], code_model)
-
-        # Build request builders
-        if yaml_data.get("operationGroups"):
-            for og_group in yaml_data["operationGroups"]:
-                for operation_yaml in og_group["operations"]:
-                    request_builder = get_request_builder(
-                        operation_yaml, code_model=code_model
-                    )
-                    if request_builder.overloads:
-                        code_model.request_builders.extend(request_builder.overloads)  # type: ignore
-                    code_model.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
-                        code_model.request_builders.append(
-                            get_request_builder(
-                                operation_yaml["nextOperation"], code_model=code_model
-                            )
-                        )
-
-        _build_convenience_layer(yaml_data=yaml_data, code_model=code_model)
-        code_model.package_dependency = self._build_package_dependency()
-        return code_model
-
     def _build_code_model_options(self) -> Dict[str, Any]:
         """Build en options dict from the user input while running autorest."""
         azure_arm = self.options.get("azure-arm", False)
@@ -218,6 +157,7 @@ class CodeGenerator(Plugin):
                 "default-optional-constants-to-none",
                 low_level_client or version_tolerant,
             ),
+            "generate_sample": self.options.get("generate-sample", False),
         }
 
         if options["builders_visibility"] is None:
@@ -255,8 +195,7 @@ class CodeGenerator(Plugin):
         if options["azure_arm"]:
             self.remove_cloud_errors(yaml_data)
 
-        code_model = self._create_code_model(yaml_data=yaml_data, options=options)
-
+        code_model = CodeModel(yaml_data=yaml_data, options=options)
         serializer = self.get_serializer(code_model)
         serializer.serialize()
 
@@ -330,6 +269,7 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
             "default-optional-constants-to-none": self._autorestapi.get_boolean_value(
                 "default-optional-constants-to-none"
             ),
+            "generate-sample": self._autorestapi.get_boolean_value("generate-sample"),
         }
         return {k: v for k, v in options.items() if v is not None}
 
@@ -355,7 +295,9 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
 
     def get_serializer(self, code_model: CodeModel):  # type: ignore
         return JinjaSerializerAutorest(
-            self._autorestapi, code_model, output_folder=self.output_folder
+            self._autorestapi,
+            code_model,
+            output_folder=self.output_folder,
         )
 
 

package/autorest/codegen/models/__init__.py

@@ -5,8 +5,10 @@
 # --------------------------------------------------------------------------
 import logging
 from typing import Any, Dict, Union
-from .base_model import BaseModel
+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
 from .list_type import ListType
@@ -28,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
@@ -57,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,
@@ -78,6 +79,7 @@ __all__ = [
     "BaseModel",
     "BaseType",
     "CodeModel",
+    "Client",
     "ConstantType",
     "ModelType",
     "DictionaryType",

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 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.
 
@@ -39,6 +57,9 @@ class BaseType(BaseModel, ABC):
     ) -> 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,9 +4,10 @@
 # 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,
@@ -21,10 +22,9 @@ ParameterListType = TypeVar(
         OverloadedRequestBuilderParameterList,
     ],
 )
-
-
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .client import Client
     from .operation import Operation
     from .request_builder import RequestBuilder
 
@@ -40,6 +40,7 @@ class BaseBuilder(
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
+        client: "Client",
         name: str,
         parameters: ParameterListType,
         *,
@@ -47,6 +48,7 @@ class BaseBuilder(
         want_tracing: bool = True,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.client = client
         self.name = name
         self._description: str = yaml_data.get("description", "")
         self.parameters = parameters
@@ -55,7 +57,9 @@ class BaseBuilder(
         )
         self._summary: str = yaml_data.get("summary", "")
         self.want_tracing = want_tracing
-        self.group_name: str = yaml_data["groupName"]
+        self.group_name: str = yaml_data[
+            "groupName"
+        ]  # either operationGroup or client I am on
         self.is_overload: bool = yaml_data["isOverload"]
         self.api_versions: List[str] = yaml_data["apiVersions"]
         self.added_on: Optional[str] = yaml_data.get("addedOn")

package/autorest/codegen/models/client.py

@@ -3,12 +3,19 @@
 # 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 .base 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,
+    get_request_builder,
+)
+from .parameter import Parameter, ParameterMethodLocation
 
 ParameterListType = TypeVar(
     "ParameterListType",
@@ -33,6 +40,7 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
         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,6 +54,50 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
 class Client(_ClientConfigBase[ClientGlobalParameterList]):
     """Model representing our service client"""
 
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        parameters: ClientGlobalParameterList,
+        *,
+        is_subclient: bool = False,
+    ):
+        super().__init__(yaml_data, code_model, parameters)
+        self.operation_groups: List[OperationGroup] = []
+        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.code_model.options["azure_arm"]:
             if async_mode:
@@ -55,6 +107,11 @@ 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"""
@@ -72,7 +129,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
 
@@ -84,7 +141,20 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             or self.code_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()
@@ -102,10 +172,15 @@ 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",
-            f"{self.code_model.client.name}Configuration",
+            f"{self.name}Configuration",
             ImportType.LOCAL,
         )
         file_import.add_msrest_import(
@@ -117,6 +192,67 @@ 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
+            ]
+        )
+
+    @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
+        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.code_model.options["show_operations"]
+            and bool(self.request_builders)
+            and not self.code_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,7 +276,7 @@ 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}",
                 og.class_name,
@@ -184,9 +320,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 +340,18 @@ 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],
+        code_model: "CodeModel",
+        *,
+        is_subclient: bool = False,
+    ) -> "Client":
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
             parameters=ClientGlobalParameterList.from_yaml(yaml_data, code_model),
+            is_subclient=is_subclient,
         )
 
 
@@ -224,11 +365,18 @@ 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.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()
+
     @property
     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
@@ -243,8 +391,6 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
             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"
@@ -257,6 +403,30 @@ 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