@autorest/python 5.16.0 → 5.17.0

package/autorest/codegen/models/operation.py

@@ -3,227 +3,302 @@
 # 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, TYPE_CHECKING
+from itertools import chain
+from typing import (
+    Dict,
+    List,
+    Any,
+    Optional,
+    Union,
+    TYPE_CHECKING,
+    Generic,
+    TypeVar,
+    cast,
+)
+
+from .request_builder_parameter import RequestBuilderParameter
 
-from .base_builder import BaseBuilder, create_parameters
+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 .response import (
+    Response,
+    PagingResponse,
+    LROResponse,
+    LROPagingResponse,
+    get_response,
+)
 from .parameter import (
+    BodyParameter,
+    MultipartBodyParameter,
     Parameter,
-    ParameterMethodLocation,
-    get_parameter,
     ParameterLocation,
 )
 from .parameter_list import ParameterList
-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 .model_type import ModelType
+from .request_builder import OverloadedRequestBuilder, RequestBuilder
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
 _LOGGER = logging.getLogger(__name__)
 
+ResponseType = TypeVar(
+    "ResponseType",
+    bound=Union[Response, PagingResponse, LROResponse, LROPagingResponse],
+)
 
-class Operation(
-    BaseBuilder
-):  # pylint: disable=too-many-public-methods, too-many-instance-attributes
-    """Represent an self."""
 
+class OperationBase(  # pylint: disable=too-many-public-methods
+    Generic[ResponseType], BaseBuilder[ParameterList]
+):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
-        request_builder: RequestBuilder,
         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,
-        want_tracing: 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.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 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
         """
+        # 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
 
-        # 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
+    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 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)
-        )
+            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
-        )
+        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"
+    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_excp:
+        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
+        # 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]
+                [error.status_codes for error in self.non_default_errors]
             )
         )
 
-    def _imports_shared(
-        self, async_mode: bool  # pylint: disable=unused-argument
-    ) -> FileImport:
+    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:
-            if self.abstract and (param.is_multipart or param.is_data_input):
-                continue
-            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())
+        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
+            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
-            )
         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.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)
+    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
+        kwargs_to_pop: List[
+            Union[
+                Parameter,
+                RequestBuilderParameter,
+                BodyParameter,
+                MultipartBodyParameter,
+            ]
+        ],
+        location: ParameterLocation,
     ) -> bool:
         return any(
-            kwarg.has_default_value and kwarg.location == location
+            (kwarg.client_default_value or kwarg.optional)
+            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)
+    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":
+            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:
+            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"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
+                request_builder.name,
+                import_type=ImportType.LOCAL,
+            )
+        return file_import
+
+    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:
@@ -253,32 +328,16 @@ class Operation(
 
             kwargs_to_pop = self.parameters.kwargs_to_pop(is_python3_file)
             if self.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.Header
+                kwargs_to_pop, ParameterLocation.HEADER
             ) or self.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.Query
+                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)
-            if self.code_model.options["builders_visibility"] != "embedded":
-                builder_group_name = self.request_builder.builder_group_name
-                rest_import_path = "..." if async_mode else ".."
-                if builder_group_name:
-                    file_import.add_submodule_import(
-                        f"{rest_import_path}{self.code_model.rest_layer_name}",
-                        builder_group_name,
-                        import_type=ImportType.LOCAL,
-                        alias=f"rest_{builder_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.need_request_converter:
                 relative_path = "..." if async_mode else ".."
                 file_import.add_submodule_import(
@@ -317,115 +376,74 @@ class Operation(
         file_import.add_submodule_import(
             "typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if self.code_model.options["tracing"] and self.want_tracing:
+        if self.code_model.options["tracing"] and self.want_tracing and not async_mode:
             file_import.add_submodule_import(
-                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
-                f"distributed_trace{'_async' if async_mode else ''}",
+                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
 
-    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 == "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)
-                )
-            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
-            ]
-        )
+    def get_response_from_status(
+        self, status_code: Optional[Union[str, int]]
+    ) -> ResponseType:
         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)
-            )
-        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]
-            )
-        if not chosen_parameter:
+            return next(r for r in self.responses if status_code in r.status_codes)
+        except StopIteration:
             raise ValueError(
-                "You are missing a parameter that has multiple media types"
+                f"Incorrect status code {status_code}, operation {self.name}"
             )
-        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)
+
+    @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"
-    ) -> "Operation":
-        name = yaml_data["language"]["python"]["name"]
-        _LOGGER.debug("Parsing %s operation", name)
-
-        parameter_creator = get_parameter(code_model).from_yaml
-        schema_requests = [
-            SchemaRequest.from_yaml(yaml, code_model=code_model)
-            for yaml in yaml_data["requests"]
+    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", [])
         ]
-        parameters, multiple_content_type_parameters = create_parameters(
-            yaml_data, code_model, parameter_creator
-        )
-        parameter_list = ParameterList(code_model, parameters, schema_requests)
-        multiple_content_type_parameter_list = ParameterList(
-            code_model, multiple_content_type_parameters, schema_requests
-        )
         abstract = False
-        if code_model.options["version_tolerant"] and (
-            any(p for p in parameter_list if p.is_multipart or p.is_data_input)
-            or any(
-                p
-                for p in multiple_content_type_parameter_list
-                if p.is_multipart or p.is_data_input
-            )
+        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. '
@@ -436,34 +454,50 @@ class Operation(
             )
             abstract = True
 
-        if len(parameter_list.content_types) > 1:
-            for p in parameter_list.parameters:
-                if p.rest_api_name == "Content-Type":
-                    p.method_location = ParameterMethodLocation.KEYWORD_ONLY
-        request_builder = code_model.lookup_request_builder(id(yaml_data))
-
         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)