@autorest/python 5.15.0 → 5.18.0

package/autorest/codegen/models/operation.py

@@ -3,348 +3,501 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from itertools import chain
 import logging
-from typing import cast, Dict, List, Any, Optional, Union, Set
-
-from .base_builder import BaseBuilder, create_parameters
+from itertools import chain
+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 .schema_response import SchemaResponse
-from .parameter import Parameter, get_parameter, ParameterLocation
-from .parameter_list import ParameterList, get_parameter_list
-from .base_schema import BaseSchema
-from .object_schema import ObjectSchema
-from .request_builder import RequestBuilder
-from .schema_request import SchemaRequest
-from .primitive_schemas import IOSchema
+from .response import (
+    Response,
+    PagingResponse,
+    LROResponse,
+    LROPagingResponse,
+    get_response,
+)
+from .parameter import (
+    BodyParameter,
+    MultipartBodyParameter,
+    Parameter,
+    ParameterLocation,
+)
+from .parameter_list import ParameterList
+from .model_type import ModelType
+from .request_builder import OverloadedRequestBuilder, RequestBuilder
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 _LOGGER = logging.getLogger(__name__)
 
-class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-many-instance-attributes
-    """Represent an self.
-    """
+ResponseType = TypeVar(
+    "ResponseType",
+    bound=Union[Response, PagingResponse, LROResponse, LROPagingResponse],
+)
+
 
+class OperationBase(  # pylint: disable=too-many-public-methods
+    Generic[ResponseType], BaseBuilder[ParameterList]
+):
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
-        description: str,
-        api_versions: Set[str],
+        request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
         parameters: ParameterList,
-        multiple_content_type_parameters: ParameterList,
-        schema_requests: List[SchemaRequest],
-        summary: Optional[str] = None,
-        responses: Optional[List[SchemaResponse]] = None,
-        exceptions: Optional[List[SchemaResponse]] = None,
-        want_description_docstring: bool = True,
+        responses: List[ResponseType],
+        exceptions: List[Response],
+        *,
+        overloads: Optional[List["Operation"]] = None,
+        public: bool = True,
         want_tracing: bool = True,
+        abstract: bool = False,
     ) -> None:
         super().__init__(
             code_model=code_model,
             yaml_data=yaml_data,
             name=name,
-            description=description,
             parameters=parameters,
-            responses=responses,
-            schema_requests=schema_requests,
-            summary=summary,
+            overloads=overloads,
+            abstract=abstract,
+            want_tracing=want_tracing,
         )
-        self.multiple_content_type_parameters = multiple_content_type_parameters
-        self.api_versions = api_versions
-        self.multiple_content_type_parameters = multiple_content_type_parameters
-        self.exceptions = exceptions or []
-        self.want_description_docstring = want_description_docstring
-        self.want_tracing = want_tracing
-        self._request_builder: Optional[RequestBuilder] = None
+        self.overloads: List["Operation"] = overloads or []
+        self.responses = responses
+        self.public = public
+        self.request_builder = request_builder
         self.deprecated = False
+        self.exceptions = exceptions
 
     @property
-    def python_name(self) -> str:
-        return self.name
-
-    @property
-    def request_builder(self) -> RequestBuilder:
-        if not self._request_builder:
-            raise ValueError(
-                "You're calling request_builder when you haven't linked up operation to its "
-                "request builder through the code model"
-            )
-        return self._request_builder
-
-    @request_builder.setter
-    def request_builder(self, r: RequestBuilder) -> None:
-        self._request_builder = r
-
-    @property
-    def is_stream_response(self) -> bool:
-        """Is the response expected to be streamable, like a download."""
-        return any(response.is_stream_response for response in self.responses)
-
-    @property
-    def body_kwargs_to_pass_to_request_builder(self) -> List[str]:
-        return [p.serialized_name for p in self.request_builder.body_kwargs_to_get]
+    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
         """
-
-        # successful status codes of responses that have bodies
-        status_codes_for_responses_with_bodies = [
-            code for code in self.success_status_code
-            if isinstance(code, int) and self.get_response_from_status(code).has_body
-        ]
-
-        successful_responses = [
-            response for response in self.responses
-            if any(code in self.success_status_code for code in response.status_codes)
-        ]
-
-        return (
-            self.has_response_body and
-            len(successful_responses) > 1 and
-            len(self.success_status_code) != len(status_codes_for_responses_with_bodies)
-        )
+        # 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"
 
     @property
-    def serialization_context(self) -> str:
-        # FIXME Do the serialization context (XML)
-        return ""
+    def pylint_disable(self) -> str:
+        retval: str = ""
+        if 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")
+        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)"
+        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.has_body or response.is_stream_response for response in self.responses)
+        """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.has_headers for response in self.responses)
+        return any(response.headers for response in self.responses)
 
     @property
-    def default_exception(self) -> Optional[str]:
-        default_excp = [excp for excp in self.exceptions for code in excp.status_codes if code == "default"]
-        if not default_excp:
+    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
-        excep_schema = default_excp[0].schema
-        if isinstance(excep_schema, ObjectSchema):
+        excep_schema = default_exceptions[0].type
+        if isinstance(excep_schema, ModelType):
             return f"_models.{excep_schema.name}"
-        # in this case, it's just an AnySchema
-        return "\'object\'"
+        # in this case, it's just an AnyType
+        return "'object'"
 
     @property
-    def status_code_exceptions(self) -> List[SchemaResponse]:
-        return [excp for excp in self.exceptions if list(excp.status_codes) != ["default"]]
+    def non_default_errors(self) -> List[Response]:
+        return [e for e in self.exceptions if "default" not in e.status_codes]
 
     @property
-    def status_code_exceptions_status_codes(self) -> List[Union[str, int]]:
+    def non_default_error_status_codes(self) -> List[Union[str, int]]:
         """Actually returns all of the status codes from exceptions (besides default)"""
-        return list(chain.from_iterable([
-            excp.status_codes for excp in self.status_code_exceptions
-        ]))
+        return list(
+            chain.from_iterable(
+                [error.status_codes for error in self.non_default_errors]
+            )
+        )
 
-    def _imports_shared(self, async_mode: bool) -> FileImport: # pylint: disable=unused-argument
+    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        for param in self.parameters.method:
-            file_import.merge(param.imports())
-
-        for param in self.multiple_content_type_parameters:
-            file_import.merge(param.imports())
-
-        for response in self.responses:
-            file_import.merge(response.imports(self.code_model))
-            if response.has_body:
-                file_import.merge(cast(BaseSchema, response.schema).imports())
+        file_import.add_submodule_import(
+            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
+        if not self.abstract:
+            for param in self.parameters.method:
+                file_import.merge(param.imports(async_mode, **kwargs))
 
-        response_types = [r.type_annotation(is_operation_file=True) for r in self.responses if r.has_body]
+        response_types = [
+            r.type_annotation(async_mode=async_mode) 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.is_stream_response:
-            file_import.add_submodule_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import(
+                "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
         return file_import
 
-
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:  # pylint: disable=unused-argument
-        return self._imports_shared(async_mode)
-
-    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
-        file_import = self._imports_base(async_mode, is_python3_file)
-        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)
+    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
+        for response in self.responses:
+            file_import.merge(
+                response.imports_for_multiapi(async_mode=async_mode, **kwargs)
+            )
+        if self.code_model.options["models_mode"]:
+            for exception in self.exceptions:
+                file_import.merge(
+                    exception.imports_for_multiapi(async_mode=async_mode, **kwargs)
+                )
         return file_import
 
     @staticmethod
-    def has_kwargs_to_pop_with_default(kwargs_to_pop: List[Parameter], location: ParameterLocation) -> bool:
-        return any(kwarg.has_default_value and kwarg.location == location for kwarg in kwargs_to_pop)
-
-    def _imports_base(self, async_mode: bool, is_python3_file: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
-
-        # Exceptions
-        file_import.add_submodule_import("azure.core.exceptions", "map_error", ImportType.AZURECORE)
-        if self.code_model.options["azure_arm"]:
-            file_import.add_submodule_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE)
-        file_import.add_submodule_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
-
-        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)
-        file_import.add_submodule_import("azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE)
-        file_import.add_submodule_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE)
-        kwargs_to_pop = self.parameters.kwargs_to_pop(is_python3_file)
-        if (self.has_kwargs_to_pop_with_default(kwargs_to_pop, ParameterLocation.Header) or
-            self.has_kwargs_to_pop_with_default(kwargs_to_pop, ParameterLocation.Query)):
-            file_import.add_submodule_import("azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE)
-        if async_mode:
-            file_import.add_submodule_import("azure.core.pipeline.transport", "AsyncHttpResponse", ImportType.AZURECORE)
-        else:
-            file_import.add_submodule_import("azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE)
-
-        if self.deprecated:
-            file_import.add_import("warnings", ImportType.STDLIB)
+    def has_kwargs_to_pop_with_default(
+        kwargs_to_pop: List[
+            Union[
+                Parameter,
+                RequestBuilderParameter,
+                BodyParameter,
+                MultipartBodyParameter,
+            ]
+        ],
+        location: ParameterLocation,
+    ) -> bool:
+        return any(
+            (kwarg.client_default_value or kwarg.optional)
+            and kwarg.location == location
+            for kwarg in kwargs_to_pop
+        )
 
+    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()
         if self.code_model.options["builders_visibility"] != "embedded":
-            builder_group_name = self.request_builder.builder_group_name
+            group_name = request_builder.group_name
             rest_import_path = "..." if async_mode else ".."
-            if builder_group_name:
+            if group_name:
                 file_import.add_submodule_import(
                     f"{rest_import_path}{self.code_model.rest_layer_name}",
-                    builder_group_name,
+                    group_name,
                     import_type=ImportType.LOCAL,
-                    alias=f"rest_{builder_group_name}"
+                    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"
+                    alias="rest",
                 )
-        if self.code_model.options["builders_visibility"] == "embedded" and not async_mode:
-            file_import.merge(self.request_builder.imports())
-        if self.code_model.need_request_converter:
-            relative_path = "..." if async_mode else ".."
+        if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
+            suffix = (
+                "_py3"
+                if self.code_model.options["add_python3_operation_files"]
+                and not self.code_model.options["python3_only"]
+                else ""
+            )
             file_import.add_submodule_import(
-                f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
+                f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
+                request_builder.name,
+                import_type=ImportType.LOCAL,
             )
+        return file_import
 
-        if self.code_model.options["version_tolerant"] and (
-            self.parameters.has_body or
-            any(r for r in self.responses if r.has_body)
-        ):
-            file_import.define_mypy_type("JSONType", "Any")
-        if self.code_model.options["tracing"] and self.want_tracing:
+    def imports(
+        self, async_mode: bool, is_python3_file: bool, **kwargs: Any
+    ) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
+
+        for response in self.responses:
+            file_import.merge(response.imports(async_mode=async_mode, **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(**kwargs))
+
+        # Exceptions
+        if self.abstract:
+            file_import.add_import("abc", ImportType.STDLIB)
+        else:
+            file_import.add_submodule_import(
+                "azure.core.exceptions", "map_error", ImportType.AZURECORE
+            )
+            if self.code_model.options["azure_arm"]:
+                file_import.add_submodule_import(
+                    "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
+                )
             file_import.add_submodule_import(
-                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
-                f"distributed_trace{'_async' if async_mode else ''}",
+                "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
+            )
+            file_import.add_submodule_import(
+                "azure.core.exceptions",
+                "ClientAuthenticationError",
                 ImportType.AZURECORE,
             )
-        return file_import
+            file_import.add_submodule_import(
+                "azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE
+            )
+            file_import.add_submodule_import(
+                "azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE
+            )
+
+            kwargs_to_pop = self.parameters.kwargs_to_pop(is_python3_file)
+            if self.has_kwargs_to_pop_with_default(
+                kwargs_to_pop, ParameterLocation.HEADER
+            ) or self.has_kwargs_to_pop_with_default(
+                kwargs_to_pop, ParameterLocation.QUERY
+            ):
+                file_import.add_submodule_import(
+                    "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+                )
+            if self.deprecated:
+                file_import.add_import("warnings", ImportType.STDLIB)
 
-    def _get_body_param_from_body_kwarg(self, body_kwarg: Parameter) -> Parameter:
-        # determine which of the body parameters returned from m4 corresponds to this body_kwarg
-        if not self.multiple_content_type_parameters.has_body:
-            return self.parameters.body[0]
-        if body_kwarg.serialized_name == "data":
-            return next(p for p in self.multiple_content_type_parameters.body if p.is_data_input)
-        if body_kwarg.serialized_name == "files":
-            return next(p for p in self.multiple_content_type_parameters.body if p.is_multipart)
-        if body_kwarg.serialized_name == "json":
-            # first check if there's any non-binary. In the case of multiple content types, there's
-            # usually one binary (for content), and one schema parameter (for json)
-            try:
-                return next(
-                    p for p in self.multiple_content_type_parameters.body
-                    if not isinstance(p.schema, IOSchema)
+            if self.code_model.need_request_converter:
+                relative_path = "..." if async_mode else ".."
+                file_import.add_submodule_import(
+                    f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
                 )
-            except StopIteration:
-                return next(p for p in self.multiple_content_type_parameters.body if p.is_json_parameter)
-        return self.multiple_content_type_parameters.body[0]
-
-    def link_body_kwargs_to_body_params(self) -> None:
-        if not self.parameters.has_body:
-            return
-        body_kwargs = [
-            p for p in self.request_builder.parameters.body
-            if p.content_types
-        ]
-        if len(body_kwargs) == 1:
-            self.parameters.body[0].body_kwargs = [body_kwargs[0]]
-            return
-        for body_kwarg in body_kwargs:
-            body_param = self._get_body_param_from_body_kwarg(body_kwarg)
-            body_param.body_kwargs.append(body_kwarg)
-
-    def convert_multiple_content_type_parameters(self) -> None:
-        type_annot = ", ".join([
-            param.schema.type_annotation(is_operation_file=True)
-            for param in self.multiple_content_type_parameters
-        ])
-        docstring_type = " or ".join([
-            param.schema.docstring_type for param in self.multiple_content_type_parameters
-        ])
-        try:
-            # get an optional param with object first. These params are the top choice
-            # bc they have more info about how to serialize the body
-            chosen_parameter = next(
-                p for p in self.multiple_content_type_parameters
-                if not p.required and isinstance(p.schema, ObjectSchema)
+        if async_mode:
+            file_import.add_submodule_import(
+                "azure.core.pipeline.transport",
+                "AsyncHttpResponse",
+                ImportType.AZURECORE,
             )
-        except StopIteration:  # pylint: disable=broad-except
-            # otherwise, we get the first optional param, if that exists. If not, we just grab the first one
-            optional_parameters = [p for p in self.multiple_content_type_parameters if not p.required]
-            chosen_parameter = (
-                optional_parameters[0] if optional_parameters else self.multiple_content_type_parameters[0]
+        else:
+            file_import.add_submodule_import(
+                "azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE
             )
-        if not chosen_parameter:
-            raise ValueError("You are missing a parameter that has multiple media types")
-        chosen_parameter.multiple_content_types_type_annot = f"Union[{type_annot}]"
-        chosen_parameter.multiple_content_types_docstring_type = docstring_type
-        self.parameters.append(chosen_parameter)
-
-    @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "Operation":
-        name = yaml_data["language"]["python"]["name"]
-        _LOGGER.debug("Parsing %s operation", name)
-
-        parameter_creator = get_parameter(code_model).from_yaml
-        parameter_list_creator = get_parameter_list(code_model)
-        schema_requests = [SchemaRequest.from_yaml(yaml, code_model=code_model) for yaml in yaml_data["requests"]]
-        parameters, multiple_content_type_parameters = create_parameters(
-            yaml_data, code_model, parameter_creator
+        if (
+            self.code_model.options["builders_visibility"] == "embedded"
+            and not async_mode
+        ):
+            file_import.merge(self.request_builder.imports())
+        file_import.add_submodule_import(
+            "azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.core.rest", "HttpRequest", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        parameter_list = parameter_list_creator(code_model, parameters, schema_requests)
-        multiple_content_type_parameter_list = parameter_list_creator(
-            code_model, multiple_content_type_parameters, schema_requests
+        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(
+                f"azure.core.tracing.decorator",
+                f"distributed_trace",
+                ImportType.AZURECORE,
+            )
+        if not self.abstract:
+            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)
+        return file_import
 
-        if len(parameter_list.content_types) > 1:
-            for p in parameter_list.parameters:
-                if p.rest_api_name == "Content-Type":
-                    p.is_keyword_only = True
+    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:
+            raise ValueError(
+                f"Incorrect status code {status_code}, operation {self.name}"
+            )
+
+    @property
+    def success_status_codes(self) -> List[Union[str, int]]:
+        """The list of all successfull status code."""
+        return [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.module_name
+
+        if (
+            basename == "operations"
+            or self.code_model.options["combine_operation_files"]
+        ):
+            return f"_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 from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+        name = yaml_data["name"]
+        request_builder = code_model.lookup_request_builder(id(yaml_data))
+        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)
+            for overload in yaml_data.get("overloads", [])
+        ]
+        abstract = False
+        if (
+            code_model.options["version_tolerant"]
+            and parameter_list.has_body
+            and isinstance(parameter_list.body_parameter, MultipartBodyParameter)
+        ):
+            _LOGGER.warning(
+                'Not going to generate operation "%s" because it has multipart / urlencoded body parameters. '
+                "Multipart / urlencoded body parameters are not supported for version tolerant generation right now. "
+                'Please write your own custom operation in the "_patch.py" file '
+                "following https://aka.ms/azsdk/python/dpcodegen/python/customize",
+                name,
+            )
+            abstract = True
 
         return cls(
-            code_model=code_model,
             yaml_data=yaml_data,
+            code_model=code_model,
+            request_builder=request_builder,
             name=name,
-            description=yaml_data["language"]["python"]["description"],
-            api_versions=set(value_dict["version"] for value_dict in yaml_data["apiVersions"]),
             parameters=parameter_list,
-            multiple_content_type_parameters=multiple_content_type_parameter_list,
-            schema_requests=schema_requests,
-            summary=yaml_data["language"]["python"].get("summary"),
-            responses=[
-                SchemaResponse.from_yaml(yaml, code_model=code_model)
-                for yaml in yaml_data.get("responses", [])
-            ],
-            # Exception with no schema means default exception, we don't store them
-            exceptions=[
-                SchemaResponse.from_yaml(yaml, code_model=code_model)
-                for yaml in yaml_data.get("exceptions", []) if "schema" in yaml
-            ],
+            overloads=overloads,
+            responses=responses,
+            exceptions=exceptions,
+            want_tracing=not yaml_data["isOverload"],
+            abstract=abstract,
         )
+
+
+class Operation(OperationBase[Response]):
+    def imports(
+        self, async_mode: bool, is_python3_file: bool, **kwargs: Any
+    ) -> FileImport:
+        file_import = super().imports(async_mode, is_python3_file, **kwargs)
+        if async_mode:
+            file_import.add_submodule_import(
+                f"azure.core.tracing.decorator_async",
+                f"distributed_trace_async",
+                ImportType.AZURECORE,
+            )
+        if self.abstract:
+            return file_import
+        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") -> OperationBase:
+    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)