@autorest/python 6.10.1 → 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

@@ -3,15 +3,14 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Type, Tuple, Union
 import re
 from autorest.codegen.models.imports import FileImport, ImportType, TypingSection
 from .base import BaseType
-from .model_type import JSONModelType
+from .model_type import ModelType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
-    from .model_type import ModelType
 
 
 class CombinedType(BaseType):
@@ -66,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:
@@ -129,19 +127,14 @@ class CombinedType(BaseType):
             [build_type(t, code_model) for t in yaml_data["types"]],
         )
 
-    @staticmethod
-    def _get_json_model_type(t: BaseType) -> Optional[JSONModelType]:
-        if isinstance(t, JSONModelType):
-            return t
-        if isinstance(t, CombinedType):
-            try:
-                return next(
-                    CombinedType._get_json_model_type(sub_t) for sub_t in t.types
-                )
-            except StopIteration:
-                pass
+    def target_model_subtype(
+        self,
+        target_types: Union[
+            Tuple[Type[ModelType]],
+            Tuple[Type[ModelType], Type[ModelType]],
+        ],
+    ) -> Optional[ModelType]:
+        for sub_t in self.types:
+            if isinstance(sub_t, target_types):
+                return sub_t  # type: ignore
         return None
-
-    @property
-    def json_subtype(self) -> Optional[JSONModelType]:
-        return CombinedType._get_json_model_type(self)

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,
@@ -271,7 +271,7 @@ class BodyParameter(_ParameterBase):
     @property
     def has_json_model_type(self) -> bool:
         if isinstance(self.type, CombinedType):
-            return self.type.json_subtype is not None
+            return self.type.target_model_subtype((JSONModelType,)) is not None
         return isinstance(self.type, JSONModelType)
 
     @classmethod

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/builder_serializer.py

@@ -30,6 +30,8 @@ from ..models import (
     Property,
     RequestBuilderType,
     CombinedType,
+    JSONModelType,
+    DPGModelType,
     ParameterListType,
     ByteArraySchema,
 )
@@ -181,8 +183,10 @@ def _serialize_json_model_body(
         for property_name, parameter_name in body_parameter.property_to_parameter_name.items()
     )
     model_type = cast(ModelType, body_parameter.type)
-    if isinstance(model_type, CombinedType) and model_type.json_subtype:
-        model_type = model_type.json_subtype
+    if isinstance(model_type, CombinedType) and model_type.target_model_subtype(
+        (JSONModelType,)
+    ):
+        model_type = model_type.target_model_subtype((JSONModelType,))
     retval.append(f"    {body_parameter.client_name} = {{{parameter_string}}}")
     retval.append(f"    {body_parameter.client_name} =  {{")
     retval.append(
@@ -320,6 +324,10 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         description_list.append("")
         return description_list
 
+    @staticmethod
+    def line_too_long(docs: List[str]) -> bool:
+        return any(len(line) > 120 for line in docs)
+
     def example_template(self, builder: BuilderType) -> List[str]:
         template = []
         if builder.abstract:
@@ -376,18 +384,21 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
         if (
             isinstance(body_param.type, (ListType, DictionaryType))
-            and self.code_model.options["models_mode"]
+            and self.code_model.options["models_mode"] == "msrest"
         ):
             return template
 
-        if isinstance(body_param.type, ModelType) and body_param.type.base != "json":
+        if isinstance(body_param.type, ModelType) and body_param.type.base == "msrest":
             return template
 
         json_type = body_param.type
         if isinstance(body_param.type, CombinedType):
-            if body_param.type.json_subtype is None:
+            target_model_type = body_param.type.target_model_subtype(
+                (JSONModelType, DPGModelType)
+            )
+            if target_model_type is None:
                 return template
-            json_type = body_param.type.json_subtype
+            json_type = target_model_type
 
         polymorphic_subtypes: List[ModelType] = []
         json_type.get_polymorphic_subtypes(polymorphic_subtypes)
@@ -597,7 +608,7 @@ class _OperationSerializer(
 
     def example_template(self, builder: OperationType) -> List[str]:
         retval = super().example_template(builder)
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models_mode"] == "msrest":
             return retval
         for response in builder.responses:
             polymorphic_subtypes: List[ModelType] = []

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/codegen/templates/operation_groups_container.py.jinja2

@@ -1,7 +1,7 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {% set operations_description = "async operations" if async_mode else "operations" %}
 {% set return_none_type_annotation = " -> None" if async_mode else "" %}
-# pylint: disable=too-many-lines
+# pylint: disable=too-many-lines,too-many-statements
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 {{ imports }}

package/autorest/codegen/templates/operation_tools.jinja2

@@ -1,9 +1,13 @@
 {% macro wrap_string(string, wrapstring, width=95) %}{{ string | wordwrap(width=width, break_long_words=False, break_on_hyphens=False, wrapstring=wrapstring)}}{% endmacro %}
 
 {% macro description(builder, serializer) %}
+{% set example_template = serializer.example_template(builder) %}
     {% for description in serializer.description_and_summary(builder) %}
         {% if description %}
 {% set description = wrap_string(description, wrapstring='\n') %}
+            {% if serializer.line_too_long(example_template) and loop.first %}
+# pylint: disable=line-too-long
+            {% endif %}
 {{ '"""' + description if loop.first else description }}
         {% else %}
 
@@ -16,11 +20,11 @@
 
         {% endif %}
 {% endfor %}
-{% if serializer.example_template(builder) %}
+{% if example_template %}
 
 Example:
     .. code-block:: python
-    {% for template_line in serializer.example_template(builder) %}
+    {% for template_line in example_template %}
         {% if template_line %}
             {% set wrap_amount = (template_line | length) - (template_line.lstrip() | length) + 10 %}
         {{  wrap_string(template_line, wrapstring='\n' + " " * wrap_amount, width=(95 - wrap_amount)) }}

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.1",
+  "version": "6.11.0",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {

package/requirements.txt

@@ -10,3 +10,4 @@ pathspec==0.11.1
 platformdirs==3.2.0
 PyYAML==6.0.1
 tomli==2.0.1
+setuptools==58.3.0