@typespec/http-client-python 0.4.4 → 0.5.1

package/generator/build/lib/pygen/codegen/models/operation.py

@@ -0,0 +1,509 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import (
+    Dict,
+    List,
+    Any,
+    Optional,
+    Union,
+    TYPE_CHECKING,
+    Generic,
+    TypeVar,
+    cast,
+)
+
+from .request_builder_parameter import RequestBuilderParameter
+
+from .utils import OrderedSet, add_to_pylint_disable
+from .base_builder import BaseBuilder
+from .imports import FileImport, ImportType, TypingSection
+from .response import (
+    Response,
+    PagingResponse,
+    LROResponse,
+    LROPagingResponse,
+    get_response,
+)
+from .parameter import (
+    BodyParameter,
+    Parameter,
+    ParameterLocation,
+)
+from .parameter_list import ParameterList
+from .model_type import ModelType
+from .base import BaseType
+from .request_builder import OverloadedRequestBuilder, RequestBuilder
+from ...utils import xml_serializable, json_serializable, NAME_LENGTH_LIMIT
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .client import Client
+    from . import OperationType
+
+ResponseType = TypeVar(
+    "ResponseType",
+    bound=Union[Response, PagingResponse, LROResponse, LROPagingResponse],
+)
+
+
+def is_internal(target: Optional[BaseType]) -> bool:
+    return isinstance(target, ModelType) and target.base == "dpg" and target.internal
+
+
+class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instance-attributes
+    Generic[ResponseType], BaseBuilder[ParameterList, List["Operation"]]
+):
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
+        name: str,
+        request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
+        parameters: ParameterList,
+        responses: List[ResponseType],
+        exceptions: List[Response],
+        *,
+        overloads: Optional[List["Operation"]] = None,
+    ) -> None:
+        super().__init__(
+            code_model=code_model,
+            client=client,
+            yaml_data=yaml_data,
+            name=name,
+            parameters=parameters,
+            overloads=overloads,
+        )
+        self.overloads: List["Operation"] = overloads or []
+        self.responses = responses
+        self.request_builder = request_builder
+        self.deprecated = False
+        self.exceptions = exceptions
+        self.is_lro_initial_operation: bool = self.yaml_data.get("isLroInitialOperation", False)
+        self.include_documentation: bool = not self.is_lro_initial_operation
+        self.internal: bool = self.yaml_data.get("internal", False)
+        if self.internal and not self.name.startswith("_"):
+            self.name = "_" + self.name
+        self.has_etag: bool = self.yaml_data.get("hasEtag", False)
+        self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
+
+    @property
+    def stream_value(self) -> Union[str, bool]:
+        return (
+            f'kwargs.pop("stream", {self.has_stream_response})'
+            if self.expose_stream_keyword and self.has_response_body
+            else self.has_stream_response
+        )
+
+    @property
+    def has_form_data_body(self):
+        return self.parameters.has_form_data_body
+
+    @property
+    def expose_stream_keyword(self) -> bool:
+        return self.yaml_data.get("exposeStreamKeyword", False)
+
+    @property
+    def operation_type(self) -> str:
+        return "operation"
+
+    @property
+    def has_optional_return_type(self) -> bool:
+        """Has optional return type if there are multiple successful response types where some have
+        bodies and some are None
+        """
+        # means if we have at least one successful response with a body and one without
+        successful_response_with_body = any(r for r in self.responses if r.type)
+        successful_response_without_body = any(r for r in self.responses if not r.type)
+        return successful_response_with_body and successful_response_without_body
+
+    def response_type_annotation(self, **kwargs) -> str:
+        if self.code_model.options["head_as_boolean"] and self.request_builder.method.lower() == "head":
+            return "bool"
+        response_type_annotations: OrderedSet[str] = {
+            response.type_annotation(**kwargs): None for response in self.responses if response.type
+        }
+        response_str = ", ".join(response_type_annotations.keys())
+        if len(response_type_annotations) > 1:
+            return f"Union[{response_str}]"
+        if self.has_optional_return_type:
+            return f"Optional[{response_str}]"
+        if self.responses:
+            return self.responses[0].type_annotation(**kwargs)
+        return "None"
+
+    def pylint_disable(self, async_mode: bool) -> str:
+        retval: str = ""
+        if not async_mode and not self.is_overload and self.response_type_annotation(async_mode=False) == "None":
+            # doesn't matter if it's async or not
+            retval = add_to_pylint_disable(retval, "inconsistent-return-statements")
+        if len(self.name) > NAME_LENGTH_LIMIT:
+            retval = add_to_pylint_disable(retval, "name-too-long")
+        return retval
+
+    def cls_type_annotation(self, *, async_mode: bool) -> str:
+        if self.request_builder.method.lower() == "head" and self.code_model.options["head_as_boolean"]:
+            return "ClsType[None]"
+        return f"ClsType[{self.response_type_annotation(async_mode=async_mode)}]"
+
+    def _response_docstring_helper(self, attr_name: str, **kwargs: Any) -> str:
+        responses_with_body = [r for r in self.responses if r.type]
+        if self.request_builder.method.lower() == "head" and self.code_model.options["head_as_boolean"]:
+            return "bool"
+        if responses_with_body:
+            response_docstring_values: OrderedSet[str] = {
+                getattr(response, attr_name)(**kwargs): None for response in responses_with_body
+            }
+            retval = " or ".join(response_docstring_values.keys())
+            if self.has_optional_return_type:
+                retval += " or None"
+            return retval
+        if self.responses:
+            return getattr(self.responses[0], attr_name)(**kwargs)
+        return "None"
+
+    def response_docstring_text(self, **kwargs) -> str:
+        retval = self._response_docstring_helper("docstring_text", **kwargs)
+        if not self.code_model.options["version_tolerant"]:
+            retval += " or the result of cls(response)"
+        if self.code_model.options["models_mode"] == "dpg" and any(
+            isinstance(r.type, ModelType) for r in self.responses
+        ):
+            r = next(r for r in self.responses if isinstance(r.type, ModelType))
+            item_type = getattr(r, "item_type", getattr(r, "type"))
+            if item_type:
+                type_name = item_type.docstring_text(**kwargs)
+                retval += f". The {type_name} is compatible with MutableMapping"
+        return retval
+
+    def response_docstring_type(self, **kwargs) -> str:
+        return self._response_docstring_helper("docstring_type", **kwargs)
+
+    @property
+    def has_response_body(self) -> bool:
+        """Tell if at least one response has a body."""
+        return any(response.type for response in self.responses)
+
+    @property
+    def any_response_has_headers(self) -> bool:
+        return any(response.headers for response in self.responses)
+
+    @property
+    def default_error_deserialization(self) -> Optional[str]:
+        default_exceptions = [e for e in self.exceptions if "default" in e.status_codes and e.type]
+        if not default_exceptions:
+            return None
+        exception_schema = default_exceptions[0].type
+        if isinstance(exception_schema, ModelType):
+            return exception_schema.type_annotation(skip_quote=True)
+        return None if self.code_model.options["models_mode"] == "dpg" else "'object'"
+
+    @property
+    def non_default_errors(self) -> List[Response]:
+        return [
+            e for e in self.exceptions if "default" not in e.status_codes and e.type and isinstance(e.type, ModelType)
+        ]
+
+    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
+        file_import = FileImport(self.code_model)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+
+        response_types = [r.type_annotation(async_mode=async_mode, operation=self) for r in self.responses if r.type]
+        if len(set(response_types)) > 1:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if self.added_on:
+            file_import.add_submodule_import(
+                f"{'.' if async_mode else ''}.._validation",
+                "api_version_validation",
+                ImportType.LOCAL,
+            )
+        return file_import
+
+    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        if self.abstract:
+            return FileImport(self.code_model)
+        file_import = self._imports_shared(async_mode, **kwargs)
+        for param in self.parameters.method:
+            file_import.merge(
+                param.imports_for_multiapi(
+                    async_mode,
+                    operation=self,
+                    **kwargs,
+                )
+            )
+        for response in self.responses:
+            file_import.merge(response.imports_for_multiapi(async_mode=async_mode, operation=self, **kwargs))
+        if self.code_model.options["models_mode"]:
+            for exception in self.exceptions:
+                file_import.merge(exception.imports_for_multiapi(async_mode=async_mode, operation=self, **kwargs))
+        return file_import
+
+    @staticmethod
+    def has_kwargs_to_pop_with_default(
+        kwargs_to_pop: List[
+            Union[
+                Parameter,
+                RequestBuilderParameter,
+                BodyParameter,
+            ]
+        ],
+        location: ParameterLocation,
+    ) -> bool:
+        return any(
+            (kwarg.client_default_value or kwarg.optional) and kwarg.location == location for kwarg in kwargs_to_pop
+        )
+
+    @property
+    def need_validation(self) -> bool:
+        """Whether we need parameter / operation validation. For API version."""
+        return bool(self.added_on) or any(p for p in self.parameters if p.added_on)
+
+    def get_request_builder_import(
+        self,
+        request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
+        async_mode: bool,
+    ) -> FileImport:
+        """Helper method to get a request builder import."""
+        file_import = FileImport(self.code_model)
+        if self.code_model.options["builders_visibility"] != "embedded":
+            group_name = request_builder.group_name
+            rest_import_path = "..." if async_mode else ".."
+            if group_name:
+                file_import.add_submodule_import(
+                    f"{rest_import_path}{self.code_model.rest_layer_name}",
+                    group_name,
+                    import_type=ImportType.LOCAL,
+                    alias=f"rest_{group_name}",
+                )
+            else:
+                file_import.add_submodule_import(
+                    rest_import_path,
+                    self.code_model.rest_layer_name,
+                    import_type=ImportType.LOCAL,
+                    alias="rest",
+                )
+        if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
+            file_import.add_submodule_import(
+                f"...{self.code_model.operations_folder_name}.{self.filename}",
+                request_builder.name,
+                import_type=ImportType.LOCAL,
+            )
+        return file_import
+
+    def imports(  # pylint: disable=too-many-branches, disable=too-many-statements
+        self, async_mode: bool, **kwargs: Any
+    ) -> FileImport:
+        if self.abstract:
+            return FileImport(self.code_model)
+        file_import = self._imports_shared(async_mode, **kwargs)
+
+        for param in self.parameters.method:
+            file_import.merge(
+                param.imports(
+                    async_mode,
+                    operation=self,
+                    **kwargs,
+                )
+            )
+        for response in self.responses:
+            file_import.merge(response.imports(async_mode=async_mode, operation=self, **kwargs))
+        if self.code_model.options["models_mode"]:
+            for exception in self.exceptions:
+                file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
+
+        if self.parameters.has_body and self.parameters.body_parameter.flattened:
+            file_import.merge(self.parameters.body_parameter.type.imports(operation=self, **kwargs))
+        if not async_mode:
+            for param in self.parameters.headers:
+                if param.wire_name.lower() == "repeatability-request-id":
+                    file_import.add_import("uuid", ImportType.STDLIB)
+                elif param.wire_name.lower() == "repeatability-first-sent":
+                    file_import.add_import("datetime", ImportType.STDLIB)
+
+        # Exceptions
+        errors = [
+            "map_error",
+            "HttpResponseError",
+            "ClientAuthenticationError",
+            "ResourceNotFoundError",
+            "ResourceExistsError",
+            "ResourceNotModifiedError",
+        ]
+        if self.stream_value:
+            errors.extend(["StreamConsumedError", "StreamClosedError"])
+        for error in errors:
+            file_import.add_submodule_import("exceptions", error, ImportType.SDKCORE)
+        if self.code_model.options["azure_arm"]:
+            file_import.add_submodule_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.SDKCORE)
+        file_import.add_mutable_mapping_import()
+
+        if self.has_kwargs_to_pop_with_default(
+            self.parameters.kwargs_to_pop, ParameterLocation.HEADER  # type: ignore
+        ) or self.has_kwargs_to_pop_with_default(
+            self.parameters.kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
+        ):
+            file_import.add_submodule_import(
+                "utils",
+                "case_insensitive_dict",
+                ImportType.SDKCORE,
+            )
+        if self.deprecated:
+            file_import.add_import("warnings", ImportType.STDLIB)
+
+        relative_path = "..." if async_mode else ".."
+        if self.has_etag:
+            file_import.add_submodule_import(
+                "exceptions",
+                "ResourceModifiedError",
+                ImportType.SDKCORE,
+            )
+            if not async_mode:
+                file_import.add_submodule_import(f"{relative_path}_vendor", "prep_if_match", ImportType.LOCAL)
+                file_import.add_submodule_import(f"{relative_path}_vendor", "prep_if_none_match", ImportType.LOCAL)
+        if async_mode:
+            file_import.add_submodule_import(
+                "rest",
+                "AsyncHttpResponse",
+                ImportType.SDKCORE,
+            )
+        else:
+            file_import.add_submodule_import(
+                "rest",
+                "HttpResponse",
+                ImportType.SDKCORE,
+            )
+        if self.code_model.options["builders_visibility"] == "embedded" and not async_mode:
+            file_import.merge(self.request_builder.imports())
+        file_import.add_submodule_import(
+            f"{'' if self.code_model.is_azure_flavor else 'runtime.'}pipeline",
+            "PipelineResponse",
+            ImportType.SDKCORE,
+        )
+        file_import.add_submodule_import("rest", "HttpRequest", ImportType.SDKCORE)
+        file_import.add_submodule_import("typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if self.code_model.options["tracing"] and self.want_tracing and not async_mode:
+            file_import.add_submodule_import(
+                "azure.core.tracing.decorator",
+                "distributed_trace",
+                ImportType.SDKCORE,
+            )
+        file_import.merge(self.get_request_builder_import(self.request_builder, async_mode))
+        if self.overloads:
+            file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
+        if self.code_model.options["models_mode"] == "dpg":
+            if self.parameters.has_body:
+                if self.has_form_data_body:
+                    file_import.add_submodule_import(relative_path, "_model_base", ImportType.LOCAL)
+                elif xml_serializable(self.parameters.body_parameter.default_content_type):
+                    file_import.add_submodule_import(
+                        f"{relative_path}_model_base",
+                        "_get_element",
+                        ImportType.LOCAL,
+                    )
+                elif json_serializable(self.parameters.body_parameter.default_content_type):
+                    file_import.add_submodule_import(
+                        f"{relative_path}_model_base",
+                        "SdkJSONEncoder",
+                        ImportType.LOCAL,
+                    )
+                    file_import.add_import("json", ImportType.STDLIB)
+            if any(xml_serializable(str(r.default_content_type)) for r in self.responses):
+                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize_xml", ImportType.LOCAL)
+            elif any(r.type for r in self.responses):
+                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
+            if self.default_error_deserialization or self.non_default_errors:
+                file_import.add_submodule_import(
+                    f"{relative_path}_model_base", "_failsafe_deserialize", ImportType.LOCAL
+                )
+        return file_import
+
+    def get_response_from_status(self, status_code: Optional[Union[str, int]]) -> ResponseType:
+        try:
+            return next(r for r in self.responses if status_code in r.status_codes)
+        except StopIteration as exc:
+            raise ValueError(f"Incorrect status code {status_code}, operation {self.name}") from exc
+
+    @property
+    def success_status_codes(self) -> List[Union[int, str, List[int]]]:
+        """The list of all successfull status code."""
+        return sorted([code for response in self.responses for code in response.status_codes])
+
+    @property
+    def filename(self) -> str:
+        basename = self.group_name
+        if basename == "":
+            # in a mixin
+            basename = self.code_model.clients[0].legacy_filename
+
+        if basename == "operations" or self.code_model.options["combine_operation_files"]:
+            return "_operations"
+        return f"_{basename}_operations"
+
+    @property
+    def has_stream_response(self) -> bool:
+        return any(r.is_stream_response for r in self.responses)
+
+    @classmethod
+    def get_request_builder(cls, yaml_data: Dict[str, Any], client: "Client"):
+        return client.lookup_request_builder(id(yaml_data))
+
+    @classmethod
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
+    ):
+        name = yaml_data["name"]
+        request_builder = cls.get_request_builder(yaml_data, client)
+        responses = [cast(ResponseType, get_response(r, code_model)) for r in yaml_data["responses"]]
+        exceptions = [Response.from_yaml(e, code_model) for e in yaml_data["exceptions"]]
+        parameter_list = ParameterList.from_yaml(yaml_data, code_model)
+        overloads = [cls.from_yaml(overload, code_model, client) for overload in yaml_data.get("overloads", [])]
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            client=client,
+            request_builder=request_builder,
+            name=name,
+            parameters=parameter_list,
+            overloads=overloads,
+            responses=responses,
+            exceptions=exceptions,
+        )
+
+
+class Operation(OperationBase[Response]):
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = super().imports(async_mode, **kwargs)
+        if self.abstract:
+            return file_import
+        if async_mode and self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
+                "azure.core.tracing.decorator_async",
+                "distributed_trace_async",
+                ImportType.SDKCORE,
+            )
+        if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models_mode"]:
+            file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
+
+        return file_import
+
+
+def get_operation(yaml_data: Dict[str, Any], code_model: "CodeModel", client: "Client") -> "OperationType":
+    if yaml_data["discriminator"] == "lropaging":
+        from .lro_paging_operation import LROPagingOperation as OperationCls
+    elif yaml_data["discriminator"] == "lro":
+        from .lro_operation import LROOperation as OperationCls  # type: ignore
+    elif yaml_data["discriminator"] == "paging":
+        from .paging_operation import PagingOperation as OperationCls  # type: ignore
+    else:
+        from . import Operation as OperationCls  # type: ignore
+    return OperationCls.from_yaml(yaml_data, code_model, client)

package/generator/build/lib/pygen/codegen/models/operation_group.py

@@ -0,0 +1,184 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Dict, List, Any, TYPE_CHECKING
+
+from .utils import OrderedSet
+
+from .base import BaseModel
+from .operation import get_operation
+from .imports import FileImport, ImportType, TypingSection
+from .utils import add_to_pylint_disable
+from .lro_operation import LROOperation
+from .lro_paging_operation import LROPagingOperation
+from ...utils import NAME_LENGTH_LIMIT
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .client import Client
+    from . import OperationType
+
+
+class OperationGroup(BaseModel):
+    """Represent an operation group."""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
+        operations: List["OperationType"],
+        api_versions: List[str],
+    ) -> None:
+        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:
+        return any(o for o in self.operations if o.abstract) or any(
+            operation_group.has_abstract_operations for operation_group in self.operation_groups
+        )
+
+    @property
+    def has_non_abstract_operations(self) -> bool:
+        return any(o for o in self.operations if not o.abstract) or any(
+            operation_group.has_non_abstract_operations for operation_group in self.operation_groups
+        )
+
+    @property
+    def base_class(self) -> str:
+        base_classes: List[str] = []
+        if self.is_mixin:
+            base_classes.append(f"{self.client.name}MixinABC")
+        return ", ".join(base_classes)
+
+    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
+        file_import = FileImport(self.code_model)
+        relative_path = ".." if async_mode else "."
+        for operation in self.operations:
+            file_import.merge(operation.imports_for_multiapi(async_mode, relative_path=relative_path))
+        if (self.code_model.model_types or self.code_model.enums) and self.code_model.options[
+            "models_mode"
+        ] == "msrest":
+            file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
+        return file_import
+
+    def pylint_disable(self) -> str:
+        retval: str = ""
+        if self.has_abstract_operations:
+            retval = add_to_pylint_disable(retval, "abstract-class-instantiated")
+        if len(self.operations) > 20:
+            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
+    def need_validation(self) -> bool:
+        """Whether any of its operations need validation"""
+        return any(o for o in self.operations if o.need_validation)
+
+    def imports(self, async_mode: bool) -> FileImport:
+        file_import = FileImport(self.code_model)
+
+        relative_path = ("..." if async_mode else "..") + ("." if self.client.is_subclient else "")
+        for operation in self.operations:
+            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)
+            and self.code_model.options["models_mode"] == "msrest"
+            and not self.is_mixin
+        ):
+            file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
+        if self.is_mixin:
+            file_import.add_submodule_import(".._vendor", f"{self.client.name}MixinABC", ImportType.LOCAL)
+        if self.has_abstract_operations:
+            file_import.add_submodule_import(".._vendor", "raise_if_not_implemented", ImportType.LOCAL)
+        if all(o.abstract for o in self.operations):
+            return file_import
+        file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.define_mypy_type("T", "TypeVar('T')")
+        type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, Dict[str, Any]], Any]]"
+        file_import.define_mypy_type("ClsType", type_value.format(""), type_value.format("Async"))
+        return file_import
+
+    @property
+    def filename(self) -> str:
+        return self.operations[0].filename
+
+    @property
+    def is_mixin(self) -> bool:
+        """The operation group with no name is the direct client methods."""
+        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)
+
+    @property
+    def has_form_data_body(self) -> bool:
+        operations = self.operations + [o for og in self.operation_groups for o in og.operations]
+        return any(operation.has_form_data_body for operation in operations)
+
+    @classmethod
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
+    ) -> "OperationGroup":
+        operations = [get_operation(o, code_model, client) for o in yaml_data["operations"]]
+        api_versions: OrderedSet[str] = {}
+        for operation in operations:
+            for api_version in operation.api_versions:
+                api_versions[api_version] = None
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            client=client,
+            operations=operations,
+            api_versions=list(api_versions.keys()),
+        )