@autorest/python 6.10.2 → 6.11.0

package/autorest/codegen/models/client.py

@@ -83,8 +83,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         self,
     ) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
         request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]] = []
-        for og_group in self.yaml_data["operationGroups"]:
-            for operation_yaml in og_group["operations"]:
+
+        def add_og_request_builder(og: Dict[str, Any]):
+            for operation_yaml in og["operations"]:
                 request_builder = get_request_builder(
                     operation_yaml,
                     code_model=self.code_model,
@@ -111,6 +112,14 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                             client=self,
                         )
                     )
+
+        queue = self.yaml_data["operationGroups"].copy()
+        while queue:
+            now = queue.pop(0)
+            add_og_request_builder(now)
+            if now.get("operationGroups"):
+                queue.extend(now["operationGroups"])
+
         return request_builders
 
     def pipeline_class(self, async_mode: bool) -> str:
@@ -247,7 +256,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     @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)
+        return any(og for og in self.operation_groups if og.is_mixin)
 
     @property
     def lro_operations(self) -> List["OperationType"]:
@@ -255,8 +264,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         return [
             operation
             for operation_group in self.operation_groups
-            for operation in operation_group.operations
-            if operation.operation_type in ("lro", "lropaging")
+            for operation in operation_group.lro_operations
         ]
 
     @property
@@ -267,8 +275,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     @property
     def has_operations(self) -> bool:
         return any(
-            bool(operation_group.operations)
-            for operation_group in self.operation_groups
+            operation_group.has_operations for operation_group in self.operation_groups
         )
 
     def link_lro_initial_operations(self) -> None:

package/autorest/codegen/models/combined_type.py

@@ -65,8 +65,7 @@ class CombinedType(BaseType):
 
     def type_annotation(self, **kwargs: Any) -> str:
         if self.name:
-            ret = f"_types.{self.name}"
-            return ret if kwargs.get("is_operation_file") else f'"{ret}"'
+            return f'"_types.{self.name}"'
         return self.type_definition(**kwargs)
 
     def type_definition(self, **kwargs: Any) -> str:

package/autorest/codegen/models/operation_group.py

@@ -11,6 +11,8 @@ from .base import BaseModel
 from .operation import get_operation
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
+from .lro_operation import LROOperation
+from .lro_paging_operation import LROPagingOperation
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -32,9 +34,17 @@ class OperationGroup(BaseModel):
         super().__init__(yaml_data, code_model)
         self.client = client
         self.class_name: str = yaml_data["className"]
+        self.identify_name: str = yaml_data["identifyName"]
         self.property_name: str = yaml_data["propertyName"]
         self.operations = operations
         self.api_versions = api_versions
+        self.operation_groups: List[OperationGroup] = []
+        if self.code_model.options["show_operations"]:
+            self.operation_groups = [
+                OperationGroup.from_yaml(op_group, code_model, client)
+                for op_group in self.yaml_data.get("operationGroups", [])
+            ]
+            self.link_lro_initial_operations()
 
     @property
     def has_abstract_operations(self) -> bool:
@@ -43,7 +53,7 @@ class OperationGroup(BaseModel):
     @property
     def base_class(self) -> str:
         base_classes: List[str] = []
-        if self.is_mixin and self.code_model.need_mixin_abc:
+        if self.is_mixin:
             base_classes.append(f"{self.client.name}MixinABC")
         return ", ".join(base_classes)
 
@@ -71,6 +81,8 @@ class OperationGroup(BaseModel):
             retval = add_to_pylint_disable(retval, "too-many-public-methods")
         if len(self.class_name) > NAME_LENGTH_LIMIT:
             retval = add_to_pylint_disable(retval, "name-too-long")
+        if len(self.operation_groups) > 6:
+            retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
         return retval
 
     @property
@@ -88,6 +100,13 @@ class OperationGroup(BaseModel):
             file_import.merge(
                 operation.imports(async_mode, relative_path=relative_path)
             )
+        if not self.code_model.options["combine_operation_files"]:
+            for og in self.operation_groups:
+                file_import.add_submodule_import(
+                    ".",
+                    og.class_name,
+                    ImportType.LOCAL,
+                )
         # for multiapi
         if (
             (self.code_model.public_model_types)
@@ -124,7 +143,45 @@ class OperationGroup(BaseModel):
     @property
     def is_mixin(self) -> bool:
         """The operation group with no name is the direct client methods."""
-        return self.property_name == ""
+        return self.identify_name == ""
+
+    def link_lro_initial_operations(self) -> None:
+        """Link each LRO operation to its initial operation"""
+        for operation_group in self.operation_groups:
+            for operation in operation_group.operations:
+                if isinstance(operation, (LROOperation, LROPagingOperation)):
+                    operation.initial_operation = self.lookup_operation(
+                        id(operation.yaml_data["initialOperation"])
+                    )
+
+    def lookup_operation(self, operation_id: int) -> "OperationType":
+        try:
+            return next(
+                o
+                for og in self.operation_groups
+                for o in og.operations
+                if id(o.yaml_data) == operation_id
+            )
+        except StopIteration as exc:
+            raise KeyError(f"No operation with id {operation_id} found.") from exc
+
+    @property
+    def lro_operations(self) -> List["OperationType"]:
+        return [
+            operation
+            for operation in self.operations
+            if operation.operation_type in ("lro", "lropaging")
+        ] + [
+            operation
+            for operation_group in self.operation_groups
+            for operation in operation_group.lro_operations
+        ]
+
+    @property
+    def has_operations(self) -> bool:
+        return any(
+            operation_group.has_operations for operation_group in self.operation_groups
+        ) or bool(self.operations)
 
     @classmethod
     def from_yaml(

package/autorest/codegen/models/parameter.py

@@ -179,7 +179,7 @@ class _ParameterBase(
             )
         if isinstance(self.type, CombinedType) and self.type.name:
             file_import.add_submodule_import(
-                "..",
+                "..." if async_mode else "..",
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,

package/autorest/codegen/models/response.py

@@ -120,8 +120,9 @@ class Response(BaseModel):
         if self.nullable:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if isinstance(self.type, CombinedType) and self.type.name:
+            async_mode = kwargs.get("async_mode", False)
             file_import.add_submodule_import(
-                "..",
+                "..." if async_mode else "..",
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,

package/autorest/codegen/serializers/__init__.py

@@ -34,6 +34,7 @@ from .utils import (
     extract_sample_name,
     get_namespace_from_package_name,
     get_namespace_config,
+    get_all_operation_groups_recursively,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -415,14 +416,15 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 clients=clients,
             )
         else:
-            for client in self.code_model.clients:
-                for operation_group in client.operation_groups:
-                    self._serialize_and_write_operations_file(
-                        env=env,
-                        namespace_path=namespace_path,
-                        operation_group=operation_group,
-                        clients=self.code_model.clients,
-                    )
+            for operation_group in get_all_operation_groups_recursively(
+                self.code_model.clients
+            ):
+                self._serialize_and_write_operations_file(
+                    env=env,
+                    namespace_path=namespace_path,
+                    operation_group=operation_group,
+                    clients=clients,
+                )
 
     def _serialize_and_write_version_file(
         self,

package/autorest/codegen/serializers/client_serializer.py

@@ -48,9 +48,8 @@ class ClientSerializer:
     @property
     def class_definition(self) -> str:
         class_name = self.client.name
-        has_mixin_og = any(og for og in self.client.operation_groups if og.is_mixin)
         base_class = ""
-        if has_mixin_og:
+        if self.client.has_mixin:
             base_class = f"{class_name}OperationsMixin"
         pylint_disable = self.client.pylint_disable
         if base_class:

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -7,6 +7,7 @@ from typing import Optional, List, Union
 import functools
 from jinja2 import Environment
 
+from .utils import get_all_operation_groups_recursively
 from ..models import (
     CodeModel,
     OperationGroup,
@@ -45,18 +46,18 @@ class OperationGroupsSerializer(BaseSerializer):
             for client in self.clients
             for r in client.request_builders
             if r.client.name == operation_group.client.name
-            and r.group_name == operation_group.property_name
+            and r.group_name == operation_group.identify_name
             and not r.is_overload
             and not r.abstract
             and not r.is_lro  # lro has already initial builder
         ]
 
     def serialize(self) -> str:
-        operation_groups = (
-            [self.operation_group]
-            if self.operation_group
-            else [og for client in self.clients for og in client.operation_groups]
-        )
+        if self.operation_group:
+            operation_groups = [self.operation_group]
+        else:
+            operation_groups = get_all_operation_groups_recursively(self.clients)
+
         imports = FileImport(self.code_model)
         for operation_group in operation_groups:
             imports.merge(

package/autorest/codegen/serializers/utils.py

@@ -3,9 +3,11 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional
+from typing import Optional, List
 from pathlib import Path
 
+from ..models import Client, OperationGroup
+
 
 def method_signature_and_response_type_annotation_template(
     *,
@@ -30,3 +32,15 @@ def get_namespace_config(namespace: str, multiapi: bool) -> str:
 
 def get_namespace_from_package_name(package_name: Optional[str]) -> str:
     return (package_name or "").replace("-", ".")
+
+
+def get_all_operation_groups_recursively(clients: List[Client]) -> List[OperationGroup]:
+    operation_groups = []
+    queue = []
+    for client in clients:
+        queue.extend(client.operation_groups)
+    while queue:
+        operation_groups.append(queue.pop(0))
+        if operation_groups[-1].operation_groups:
+            queue.extend(operation_groups[-1].operation_groups)
+    return operation_groups

package/autorest/codegen/templates/model_base.py.jinja2

@@ -726,7 +726,11 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
     ):
         if obj is None:
             return obj
-        return _deserialize_with_callable(deserializer, obj)
+        try:
+            return _deserialize_with_callable(deserializer, obj)
+        except Exception:
+            pass
+        return obj
 
     if get_deserializer(annotation, rf):
         return functools.partial(_deserialize_default, get_deserializer(annotation, rf))

package/autorest/codegen/templates/operation_group.py.jinja2

@@ -38,6 +38,13 @@ class {{ operation_group.class_name }}: {{ operation_group.pylint_disable }}
         {% if code_model.options["multiapi"] %}
         self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version")
         {% endif %}
+
+        {% for og in operation_group.operation_groups %}
+        self.{{ og.property_name }} = {{ og.class_name }}(
+            self._client, self._config, self._serialize, self._deserialize{{ ", self._api_version" if code_model.options["multiapi"] else "" }}
+        )
+        {% endfor %}
+
 {{ check_abstract_methods() }}
 {% elif operation_group.has_abstract_operations %}
 

package/autorest/preprocess/__init__.py

@@ -124,11 +124,9 @@ def update_description(
     return description
 
 
-def update_operation_group_class_name(
-    yaml_data: Dict[str, Any], class_name: str
-) -> str:
+def update_operation_group_class_name(prefix: str, class_name: str) -> str:
     if class_name == "":
-        return yaml_data["name"] + "OperationsMixin"
+        return prefix + "OperationsMixin"
     if class_name == "Operations":
         return "Operations"
     return class_name + "Operations"
@@ -511,7 +509,13 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
     ) -> None:
         operation_groups_yaml_data = client["operationGroups"]
         for operation_group in operation_groups_yaml_data:
-            operation_group["clientName"] = client["name"]
+            operation_group["identifyName"] = self.pad_reserved_words(
+                operation_group.get("name", operation_group["propertyName"]),
+                PadType.OPERATION_GROUP,
+            )
+            operation_group["identifyName"] = to_snake_case(
+                operation_group["identifyName"]
+            )
             operation_group["propertyName"] = self.pad_reserved_words(
                 operation_group["propertyName"], PadType.OPERATION_GROUP
             )
@@ -519,11 +523,14 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 operation_group["propertyName"]
             )
             operation_group["className"] = update_operation_group_class_name(
-                client, operation_group["className"]
+                client["name"], operation_group["className"]
             )
             for operation in operation_group["operations"]:
                 self.get_operation_updater(operation)(code_model, operation)
 
+            if operation_group.get("operationGroups"):
+                self.update_operation_groups(code_model, operation_group)
+
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
         self.update_types(yaml_data["types"])

package/autorest/preprocess/python_mappings.py

@@ -93,6 +93,7 @@ _always_reserved = [
     "yield",
     "async",
     "await",
+    "int",
 ]
 
 RESERVED_WORDS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.10.2",
+  "version": "6.11.0",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {