@autorest/python 6.1.10 → 6.2.0

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

@@ -11,29 +11,68 @@ 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.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 .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"]
+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"]
         ]
-    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()
+        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:
@@ -97,21 +136,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 +159,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 +216,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:
@@ -243,8 +242,10 @@ 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):
-        return JinjaSerializer(code_model, output_folder=self.output_folder)
+    def get_serializer(self, code_model: CodeModel, namespace_model: NamespaceModel):
+        return JinjaSerializer(
+            code_model, namespace_model, output_folder=self.output_folder
+        )
 
     def process(self) -> bool:
         # List the input file, should be only one
@@ -253,12 +254,14 @@ class CodeGenerator(Plugin):
         yaml_data = self.get_yaml()
 
         if options["azure_arm"]:
-            self.remove_cloud_errors(yaml_data)
+            for namespace in yaml_data.values():
+                self.remove_cloud_errors(namespace)
 
-        code_model = self._create_code_model(yaml_data=yaml_data, options=options)
+        code_model = _create_code_model(yaml_data=yaml_data, options=options)
 
-        serializer = self.get_serializer(code_model)
-        serializer.serialize()
+        for namespace_model in code_model.namespace_models:
+            serializer = self.get_serializer(code_model, namespace_model)
+            serializer.serialize()
 
         return True
 
@@ -330,6 +333,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}
 
@@ -353,9 +357,12 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
         # Parse the received YAML
         return yaml.safe_load(file_content)
 
-    def get_serializer(self, code_model: CodeModel):  # type: ignore
+    def get_serializer(self, code_model: CodeModel, namespace_model: NamespaceModel):  # type: ignore
         return JinjaSerializerAutorest(
-            self._autorestapi, code_model, output_folder=self.output_folder
+            self._autorestapi,
+            code_model,
+            namespace_model,
+            output_folder=self.output_folder,
         )
 
 

package/autorest/codegen/models/__init__.py

@@ -6,7 +6,8 @@
 import logging
 from typing import Any, Dict, Union
 from .base_model import BaseModel
-from .code_model import CodeModel
+from .code_model import CodeModel, NamespaceModel
+from .client import Client
 from .model_type import ModelType
 from .dictionary_type import DictionaryType
 from .list_type import ListType
@@ -78,6 +79,8 @@ __all__ = [
     "BaseModel",
     "BaseType",
     "CodeModel",
+    "Client",
+    "NamespaceModel",
     "ConstantType",
     "ModelType",
     "DictionaryType",
@@ -145,28 +148,28 @@ TYPE_TO_OBJECT = {
 _LOGGER = logging.getLogger(__name__)
 
 
-def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
+def build_type(yaml_data: Dict[str, Any], namespace_model: NamespaceModel) -> BaseType:
     yaml_id = id(yaml_data)
     try:
-        return code_model.lookup_type(yaml_id)
+        return namespace_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, code_model)
-        code_model.types_map[yaml_id] = response
-        response.fill_instance_from_yaml(yaml_data, code_model)
+        response = ModelType(yaml_data, namespace_model)
+        namespace_model.types_map[yaml_id] = response
+        response.fill_instance_from_yaml(yaml_data, namespace_model)
     else:
         object_type = yaml_data.get("type")
-        if object_type is None:
+        if object_type not in TYPE_TO_OBJECT:
             _LOGGER.warning(
                 'Unrecognized definition type "%s" is found, falling back it as "string"! ',
                 yaml_data["type"],
             )
             object_type = "string"
-        response = TYPE_TO_OBJECT[object_type].from_yaml(yaml_data, code_model)  # type: ignore
-    code_model.types_map[yaml_id] = response
+        response = TYPE_TO_OBJECT[object_type].from_yaml(yaml_data, namespace_model)  # type: ignore
+    namespace_model.types_map[yaml_id] = response
     return response
 
 

package/autorest/codegen/models/base_builder.py

@@ -13,6 +13,7 @@ from .parameter_list import (
     OverloadedRequestBuilderParameterList,
 )
 
+
 ParameterListType = TypeVar(
     "ParameterListType",
     bound=Union[
@@ -24,9 +25,10 @@ ParameterListType = TypeVar(
 
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
     from .operation import Operation
     from .request_builder import RequestBuilder
+    from .client import Client
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -39,14 +41,16 @@ class BaseBuilder(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
+        client: "Client",
         name: str,
         parameters: ParameterListType,
         *,
         overloads=None,
         want_tracing: bool = True,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        self.client = client
         self.name = name
         self._description: str = yaml_data.get("description", "")
         self.parameters = parameters
@@ -55,12 +59,14 @@ 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")
 
-        if code_model.options["version_tolerant"] and yaml_data.get("abstract"):
+        if namespace_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/base_model.py

@@ -6,7 +6,7 @@
 from typing import Any, Dict, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class BaseModel:
@@ -16,9 +16,11 @@ class BaseModel:
     :type yaml_data: dict[str, Any]
     """
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
         self.yaml_data = yaml_data
-        self.code_model = code_model
+        self.namespace_model = namespace_model
 
     @property
     def id(self) -> int:

package/autorest/codegen/models/base_type.py

@@ -10,7 +10,7 @@ from .base_model import BaseModel
 from .imports import FileImport
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
     from .model_type import ModelType
 
 
@@ -21,8 +21,10 @@ class BaseType(BaseModel, ABC):
     :type yaml_data: dict[str, Any]
     """
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
-        super().__init__(yaml_data, code_model)
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
+        super().__init__(yaml_data, namespace_model)
         self.type = yaml_data["type"]  # the type discriminator
         self.api_versions: List[str] = yaml_data.get(
             "apiVersions", []
@@ -30,9 +32,9 @@ class BaseType(BaseModel, ABC):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "BaseType":
-        return cls(yaml_data=yaml_data, code_model=code_model)
+        return cls(yaml_data=yaml_data, namespace_model=namespace_model)
 
     def imports(  # pylint: disable=no-self-use
         self, **kwargs  # pylint: disable=unused-argument