@autorest/python 5.11.2 → 5.12.0

package/ChangeLog.md

@@ -1,5 +1,31 @@
 # Change Log
 
+### 2021-12-06 - 5.12.0
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.1`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Breaking Changes in Version Tolerant Generation**
+
+- Remove metadata property for version tolerant and low level client generations #1090
+- Generate SDKs with `--python3-only` defaulting to `True` for version tolerant and low level client  #1087
+
+**New Features**
+
+- Generate a `_patch.py` file if one does not exist. These files are used to customize the generated code  #1092
+
+**Bug Fixes**
+
+- Can now handle body params with names `json`, `content`, `data`, and `files` #1081
+- Improve generated templates for `data` and `files` input body params by adding quotes around the keys  #1082
+- Using flag `--python3-only` will get you typed sync client and config files  #1085
+- Pin `mistune` dependency to less than `2.x.x` so autorest can be successfully installed  #1106
+
 ### 2021-11-05 - 5.11.2
 
 | Library | Min Version

package/autorest/codegen/__init__.py

@@ -60,7 +60,7 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
             "to 'public' or 'hidden'."
         )
 
-    if not options["show_operations"] and options["add_python_3_operation_files"]:
+    if not options["show_operations"] and options["add_python3_operation_files"]:
         raise ValueError(
             "Can not add typed sync operation files if you are not showing operations. "
             "If you want typed synced operation files, you have to add flag "
@@ -256,7 +256,7 @@ class CodeGenerator(Plugin):
         version_tolerant = self._autorestapi.get_boolean_value("version-tolerant", False)
         show_operations = self._autorestapi.get_boolean_value("show-operations", not low_level_client)
         models_mode_default = "none" if low_level_client or version_tolerant else "msrest"
-        python_3_only = self._autorestapi.get_boolean_value("python3-only", False)
+        python3_only = self._autorestapi.get_boolean_value("python3-only", low_level_client or version_tolerant)
 
         options: Dict[str, Any] = {
             "azure_arm": azure_arm,
@@ -282,13 +282,13 @@ class CodeGenerator(Plugin):
             "only_path_and_body_params_positional": self._autorestapi.get_boolean_value(
                 "only-path-and-body-params-positional", low_level_client or version_tolerant
             ),
-            "add_python_3_operation_files": self._autorestapi.get_boolean_value(
-                "add-python3-operation-files", python_3_only
+            "add_python3_operation_files": self._autorestapi.get_boolean_value(
+                "add-python3-operation-files", python3_only and not low_level_client
             ),
             "version_tolerant": version_tolerant,
             "low_level_client": low_level_client,
             "combine_operation_files": self._autorestapi.get_boolean_value("combine-operation-files", version_tolerant),
-            "python_3_only": python_3_only,
+            "python3_only": python3_only,
         }
 
         if options["builders_visibility"] is None:

package/autorest/codegen/models/client.py

@@ -96,6 +96,6 @@ class Client:
             pass
         return file_import
 
-    def send_request_signature(self, async_mode) -> List[str]:
+    def send_request_signature(self, async_mode: bool, is_python3_file: bool) -> List[str]:
         request_signature = ["request: HttpRequest," if async_mode else "request,  # type: HttpRequest"]
-        return request_signature + self.parameters.method_signature_kwargs(async_mode)
+        return request_signature + self.parameters.method_signature_kwargs(is_python3_file)

package/autorest/codegen/models/code_model.py

@@ -29,7 +29,7 @@ from .rest import Rest
 
 _LOGGER = logging.getLogger(__name__)
 
-class CodeModel:  # pylint: disable=too-many-instance-attributes
+class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     """Holds all of the information we have parsed out of the yaml file. The CodeModel is what gets
     serialized by the serializers.
 
@@ -203,6 +203,10 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
                 operation for operation in operation_group.operations if operation not in next_operations
             ]
 
+    @property
+    def has_schemas(self):
+        return self.schemas or self.enums
+
     @property
     def default_authentication_policy(self) -> Type[CredentialSchemaPolicy]:
         return ARMChallengeAuthenticationPolicy if self.options['azure_arm'] else BearerTokenCredentialPolicy

package/autorest/codegen/models/operation_group.py

@@ -56,7 +56,7 @@ class OperationGroup(BaseModel):
             file_import.merge(operation.imports_for_multiapi(async_mode))
         return file_import
 
-    def imports(self, async_mode: bool, has_schemas: bool) -> FileImport:
+    def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
         file_import.add_from_import("azure.core.exceptions", "ClientAuthenticationError", ImportType.AZURECORE)
         file_import.add_from_import("azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE)
@@ -73,7 +73,7 @@ class OperationGroup(BaseModel):
                     "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
                 )
         local_path = "..." if async_mode else ".."
-        if has_schemas and self.code_model.options["models_mode"]:
+        if self.code_model.has_schemas and self.code_model.options["models_mode"]:
             file_import.add_from_import(local_path, "models", ImportType.LOCAL, alias="_models")
         if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
             if not self.code_model.options["combine_operation_files"]:
@@ -85,7 +85,9 @@ class OperationGroup(BaseModel):
             else:
                 operation_group_builders = self.code_model.rest.request_builders
             for request_builder in operation_group_builders:
-                suffix = "_py3" if self.code_model.options["python_3_only"] else ""
+                python3_only = self.code_model.options["python3_only"]
+                typed_sync_operation_file = self.code_model.options["add_python3_operation_files"]
+                suffix = "_py3" if typed_sync_operation_file and not python3_only else ""
                 file_import.add_from_import(
                     f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
                     request_builder.name,

package/autorest/codegen/models/parameter.py

@@ -97,6 +97,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         self.is_data_input = yaml_data.get("isPartialBody", False) and not self.is_multipart
         self.content_types = content_types or []
         self.body_kwargs: List[Parameter] = []
+        self.is_body_kwarg = False
 
     def __hash__(self) -> int:
         return hash(self.serialized_name)
@@ -167,7 +168,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     @property
     def pre_semicolon_content_types(self) -> List[str]:
         """Splits on semicolon of media types and returns the first half.
-        I.e. ["text/plain; encoding=UTF-8"] -> ["text/plain"]
+        I.e. ["text/plain; charset=UTF-8"] -> ["text/plain"]
         """
         return [content_type.split(";")[0] for content_type in self.content_types]
 
@@ -282,8 +283,8 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     def has_default_value(self):
         return self.default_value is not None or not self.required
 
-    def method_signature(self, is_python_3_file: bool) -> str:
-        if is_python_3_file:
+    def method_signature(self, is_python3_file: bool) -> str:
+        if is_python3_file:
             if self.has_default_value:
                 return f"{self.serialized_name}: {self.type_annotation} = {self.default_value_declaration},"
             return f"{self.serialized_name}: {self.type_annotation},"

package/autorest/codegen/models/parameter_list.py

@@ -172,11 +172,15 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
 
     @property
     def multipart(self) -> List[Parameter]:
-        return self.get_from_predicate(lambda parameter: parameter.is_multipart)
+        return self.get_from_predicate(
+            lambda parameter: parameter.is_multipart and not parameter.is_body_kwarg
+        )
 
     @property
     def data_inputs(self) -> List[Parameter]:
-        return self.get_from_predicate(lambda parameter: parameter.is_data_input)
+        return self.get_from_predicate(
+            lambda parameter: parameter.is_data_input and not parameter.is_body_kwarg
+        )
 
     def _filter_out_multiple_content_type(self, kwarg_params):
         """We don't want multiple content type kwargs in the method signature"""
@@ -214,24 +218,24 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
         return signature_parameters
 
 
-    def method_signature(self, is_python_3_file: bool) -> List[str]:
+    def method_signature(self, is_python3_file: bool) -> List[str]:
         return _method_signature_helper(
-            positional=self.method_signature_positional(is_python_3_file),
-            keyword_only=self.method_signature_keyword_only(is_python_3_file),
-            kwarg_params=self.method_signature_kwargs(is_python_3_file)
+            positional=self.method_signature_positional(is_python3_file),
+            keyword_only=self.method_signature_keyword_only(is_python3_file),
+            kwarg_params=self.method_signature_kwargs(is_python3_file)
         )
 
-    def method_signature_positional(self, is_python_3_file: bool) -> List[str]:
-        return [parameter.method_signature(is_python_3_file) for parameter in self.positional]
+    def method_signature_positional(self, is_python3_file: bool) -> List[str]:
+        return [parameter.method_signature(is_python3_file) for parameter in self.positional]
 
-    def method_signature_keyword_only(self, is_python_3_file: bool) -> List[str]:
-        if not (self.keyword_only and is_python_3_file):
+    def method_signature_keyword_only(self, is_python3_file: bool) -> List[str]:
+        if not (self.keyword_only and is_python3_file):
             return []
-        return ["*,"] + [parameter.method_signature(is_python_3_file) for parameter in self.keyword_only]
+        return ["*,"] + [parameter.method_signature(is_python3_file) for parameter in self.keyword_only]
 
     @staticmethod
-    def method_signature_kwargs(is_python_3_file: bool) -> List[str]:
-        return ["**kwargs: Any"] if is_python_3_file else ["**kwargs  # type: Any"]
+    def method_signature_kwargs(is_python3_file: bool) -> List[str]:
+        return ["**kwargs: Any"] if is_python3_file else ["**kwargs  # type: Any"]
 
     @property
     def positional(self) -> List[Parameter]:
@@ -245,9 +249,9 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
     def kwargs(self) -> List[Parameter]:
         return [p for p in self.method if p.is_kwarg]
 
-    def kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
+    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
         kwargs_to_pop = self.kwargs
-        if not is_python_3_file:
+        if not is_python3_file:
             kwargs_to_pop += self.keyword_only
         return kwargs_to_pop
 
@@ -433,41 +437,41 @@ class GlobalParameterList(ParameterList):
             return True
         return serialized_name != self.host_variable_name
 
-    def kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
+    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
         return [
-            k for k in super().kwargs_to_pop(is_python_3_file)
+            k for k in super().kwargs_to_pop(is_python3_file)
             if not self._param_is_in_config_method(k.serialized_name)
         ]
 
-    def config_kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
-        current_kwargs_to_pop = super().kwargs_to_pop(is_python_3_file)
+    def config_kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
+        current_kwargs_to_pop = super().kwargs_to_pop(is_python3_file)
         return [k for k in current_kwargs_to_pop if self._param_is_in_config_method(k.serialized_name)]
 
     @property
     def config_method(self) -> List[Parameter]:
         return [p for p in self.method if self._param_is_in_config_method(p.serialized_name)]
 
-    def client_method_signature(self, is_python_3_file: bool) -> List[str]:
-        return self.method_signature(is_python_3_file)
+    def client_method_signature(self, is_python3_file: bool) -> List[str]:
+        return self.method_signature(is_python3_file)
 
-    def config_method_signature(self, is_python_3_file: bool) -> List[str]:
+    def config_method_signature(self, is_python3_file: bool) -> List[str]:
 
         positional = [
-            p.method_signature(is_python_3_file)
+            p.method_signature(is_python3_file)
             for p in self.positional
             if self._param_is_in_config_method(p.serialized_name)
         ]
         keyword_only_params = [p for p in self.keyword_only if self._param_is_in_config_method(p.serialized_name)]
         keyword_only_method_signature = []
-        if is_python_3_file:
+        if is_python3_file:
             keyword_only_method_signature = (
                 ["*,"] +
                 [
-                    p.method_signature(is_python_3_file) for p in keyword_only_params
+                    p.method_signature(is_python3_file) for p in keyword_only_params
                 ]
             ) if keyword_only_params else []
         return _method_signature_helper(
             positional=positional,
             keyword_only=keyword_only_method_signature,
-            kwarg_params=self.method_signature_kwargs(is_python_3_file)
+            kwarg_params=self.method_signature_kwargs(is_python3_file)
         )

package/autorest/codegen/models/request_builder.py

@@ -80,13 +80,17 @@ class RequestBuilder(BaseBuilder):
             file_import.add_from_import(
                 f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
             )
+        if self.parameters.headers or self.parameters.query:
+            file_import.add_from_import(
+                "typing", "Dict", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
+            )
         file_import.add_from_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         file_import.add_from_import("msrest", "Serializer", ImportType.AZURECORE)
         if self.parameters.has_body and (
             self.code_model.options["builders_visibility"] != "embedded" or
-            self.code_model.options["add_python_3_operation_files"]
+            self.code_model.options["add_python3_operation_files"]
         ):
             file_import.define_mypy_type("JSONType", "Any")
         return file_import

package/autorest/codegen/models/request_builder_parameter.py

@@ -29,12 +29,13 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
 
     @property
     def name_in_high_level_operation(self) -> str:
+        template = "{}" if self.code_model.options["version_tolerant"] else "_{}"
         if self.is_multipart:
-            return "files"
+            return template.format("files")
         if self.is_data_input:
-            return "data"
+            return template.format("data")
         if self.is_body and not self.constant:
-            return self.serialized_name
+            return f"_{self.serialized_name}"
         name = self.yaml_data["language"]["python"]["name"]
         if self.implementation == "Client" and self.in_method_code:
             # for these, we're passing the client params to the request builder.

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -44,6 +44,7 @@ class RequestBuilderParameterList(ParameterList):
     def _change_body_param_name(self, parameter: Parameter, name: str) -> None:
         self.body_kwarg_names[name] = None
         parameter.serialized_name = name
+        parameter.is_body_kwarg = True
 
     def _is_json(self, body_method_param: Parameter) -> bool:
         if 'json' in body_method_param.serialization_formats:
@@ -97,7 +98,6 @@ class RequestBuilderParameterList(ParameterList):
             "Multipart input for files. See the template in our example to find the input shape. " +
             file_kwarg.description
         )
-        file_kwarg.is_multipart = False
         file_kwarg.content_types = [
             c for c in content_types_to_assign
             if c == "multipart/form-data"
@@ -119,7 +119,6 @@ class RequestBuilderParameterList(ParameterList):
             "Pass in dictionary that contains form data to include in the body of the request. " +
             data_kwarg.description
         )
-        data_kwarg.is_data_input = False
         data_kwarg.content_types = [
             c for c in content_types_to_assign
             if c == "application/x-www-form-urlencoded"
@@ -208,7 +207,7 @@ class RequestBuilderParameterList(ParameterList):
         if not self._json_body:
             try:
                 json_param = next(
-                    b for b in self.body if b.serialized_name not in _REQUEST_BUILDER_BODY_NAMES and
+                    b for b in self.body if not b.is_body_kwarg and
                     b.is_json_parameter
                 )
                 self._json_body = json_param.schema
@@ -217,10 +216,10 @@ class RequestBuilderParameterList(ParameterList):
                 raise ValueError("There is no JSON body in these parameters")
         return self._json_body
 
-    def kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
+    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
         # we don't want to pop the body kwargs in py2.7. We send them straight to HttpRequest
         kwargs_to_pop = self.kwargs
-        if not is_python_3_file:
+        if not is_python3_file:
             kwargs_to_pop += [k for k in self.keyword_only if not (k.is_body and not k.constant)]
         return kwargs_to_pop
 
@@ -240,9 +239,19 @@ class RequestBuilderParameterList(ParameterList):
         seen_content_type = False
 
         for parameter in parameters:
+
+            if (
+                parameter.location == ParameterLocation.Body and
+                (parameter.is_data_input or parameter.is_multipart) and
+                not parameter.is_body_kwarg
+            ):
+                # if i am a part of files or data, and i'm not the files or
+                # data kwarg, ignore me
+                continue
             if (
                 parameter.location == ParameterLocation.Body and
-                parameter.serialized_name not in _REQUEST_BUILDER_BODY_NAMES
+                not parameter.is_body_kwarg and
+                not parameter.constant
             ):
                 # we keep the original body param from the swagger for documentation purposes
                 # we don't want it in the method signature

package/autorest/codegen/models/rest.py

@@ -19,10 +19,11 @@ class Rest(BaseModel):
         super(Rest, self). __init__(yaml_data=yaml_data)
         self.request_builders = request_builders
 
-    def imports(self) -> FileImport:
+    def imports(self, builder_group_name: str) -> FileImport:
         file_import = FileImport()
         for request_builder in self.request_builders:
-            file_import.merge(request_builder.imports())
+            if request_builder.builder_group_name == builder_group_name:
+                file_import.merge(request_builder.imports())
         return file_import
 
     @classmethod

package/autorest/codegen/serializers/__init__.py

@@ -3,29 +3,32 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
+from typing import List, Optional
 from pathlib import Path
 from jinja2 import PackageLoader, Environment
 from autorest.codegen.models.operation_group import OperationGroup
 
 from ...jsonrpc import AutorestAPI
-from ..models import CodeModel
-from ..models.request_builder import RequestBuilder
+from ..models import (
+    CodeModel,
+    OperationGroup,
+    RequestBuilder,
+)
 from .enum_serializer import EnumSerializer
 from .general_serializer import GeneralSerializer
 from .model_generic_serializer import ModelGenericSerializer
 from .model_init_serializer import ModelInitSerializer
 from .model_python3_serializer import ModelPython3Serializer
 from .operations_init_serializer import OperationsInitSerializer
-from .operation_group_serializer import OperationGroupSerializer
+from .operation_groups_serializer import OperationGroupsSerializer
 from .metadata_serializer import MetadataSerializer
 from .rest_serializer import RestPython3Serializer, RestGenericSerializer, RestSerializer
+from .patch_serializer import PatchSerializer
 
 __all__ = [
     "JinjaSerializer",
 ]
 
-
 class JinjaSerializer:
     def __init__(self, autorestapi: AutorestAPI) -> None:
         self._autorestapi = autorestapi
@@ -45,8 +48,8 @@ class JinjaSerializer:
         )
 
         # if there was a patch file before, we keep it
-        self._keep_patch_file(namespace_path / Path("_patch.py"))
-        self._keep_patch_file(namespace_path / Path("aio") / Path("_patch.py"))
+        self._keep_patch_file(namespace_path / Path("_patch.py"), env)
+        self._keep_patch_file(namespace_path / Path("aio") / Path("_patch.py"), env)
 
         self._serialize_and_write_top_level_folder(code_model=code_model, env=env, namespace_path=namespace_path)
 
@@ -70,16 +73,18 @@ class JinjaSerializer:
 
 
 
-    def _keep_patch_file(self, path_file: Path):
+    def _keep_patch_file(self, path_file: Path, env: Environment):
         if self._autorestapi.read_file(path_file):
             self._autorestapi.write_file(path_file, self._autorestapi.read_file(path_file))
+        else:
+            self._autorestapi.write_file(path_file, PatchSerializer(env=env).serialize())
 
 
     def _serialize_and_write_models_folder(self, code_model: CodeModel, env: Environment, namespace_path: Path) -> None:
         # Write the models folder
         models_path = namespace_path / Path("models")
         if code_model.schemas:
-            if not code_model.options['python_3_only']:
+            if not code_model.options['python3_only']:
                 self._autorestapi.write_file(
                     models_path / Path("_models.py"), ModelGenericSerializer(code_model=code_model, env=env).serialize()
                 )
@@ -144,36 +149,49 @@ class JinjaSerializer:
             ).serialize_init()
         )
 
-    def _serialize_and_write_operations_folder_process(
+    def _serialize_and_write_operations_file(
         self,
         code_model: CodeModel,
         env: Environment,
         namespace_path: Path,
-        operation_groups: List[OperationGroup],
-        filename: str
+        operation_group: Optional[OperationGroup] = None
     ) -> None:
-        # write sync operation group and operation files
-        if not code_model.options['python_3_only'] and not code_model.options["add_python_3_operation_files"]:
-            operation_group_serializer = OperationGroupSerializer(
+        filename = operation_group.filename if operation_group else "_operations"
+        # write first sync file
+        operation_group_serializer = OperationGroupsSerializer(
+            code_model=code_model,
+            env=env,
+            async_mode=False,
+            is_python3_file=code_model.options['python3_only'],
+            operation_group=operation_group
+        )
+        self._autorestapi.write_file(
+            namespace_path / Path(code_model.operations_folder_name) / Path(f"{filename}.py"),
+            operation_group_serializer.serialize(),
+        )
+
+        if not code_model.options['python3_only'] and code_model.options["add_python3_operation_files"]:
+            # write typed second file if not python 3 only
+            operation_group_serializer = OperationGroupsSerializer(
                 code_model=code_model,
                 env=env,
-                operation_groups=operation_groups,
                 async_mode=False,
-                is_python_3_file=False,
+                is_python3_file=True,
+
             )
             self._autorestapi.write_file(
-                namespace_path / Path(code_model.operations_folder_name) / Path(f"{filename}.py"),
+                namespace_path / Path(code_model.operations_folder_name) / Path(f"{filename}_py3.py"),
                 operation_group_serializer.serialize(),
             )
 
         if not code_model.options["no_async"]:
             # write async operation group and operation files
-            operation_group_async_serializer = OperationGroupSerializer(
+            operation_group_async_serializer = OperationGroupsSerializer(
                 code_model=code_model,
                 env=env,
-                operation_groups=operation_groups,
                 async_mode=True,
-                is_python_3_file=True,
+                is_python3_file=True,
+                operation_group=operation_group
             )
             self._autorestapi.write_file(
                 (
@@ -185,20 +203,6 @@ class JinjaSerializer:
                 operation_group_async_serializer.serialize(),
             )
 
-        if code_model.options["add_python_3_operation_files"]:
-            # write typed sync operation files
-            operation_group_serializer = OperationGroupSerializer(
-                code_model=code_model,
-                env=env,
-                operation_groups=operation_groups,
-                async_mode=False,
-                is_python_3_file=True,
-            )
-            self._autorestapi.write_file(
-                namespace_path / Path(code_model.operations_folder_name) / Path(f"{filename}_py3.py"),
-                operation_group_serializer.serialize(),
-            )
-
     def _serialize_and_write_operations_folder(
         self, code_model: CodeModel, env: Environment, namespace_path: Path
     ) -> None:
@@ -217,24 +221,20 @@ class JinjaSerializer:
                 operations_async_init_serializer.serialize(),
             )
 
-        if not code_model.options["combine_operation_files"]:
+        if code_model.options["combine_operation_files"]:
+            self._serialize_and_write_operations_file(
+                code_model=code_model,
+                env=env,
+                namespace_path=namespace_path,
+            )
+        else:
             for operation_group in code_model.operation_groups:
-                self._serialize_and_write_operations_folder_process(
+                self._serialize_and_write_operations_file(
                     code_model=code_model,
                     env=env,
                     namespace_path=namespace_path,
-                    operation_groups=[operation_group],
-                    filename=operation_group.filename
+                    operation_group=operation_group,
                 )
-        else:
-            self._serialize_and_write_operations_folder_process(
-                code_model=code_model,
-                env=env,
-                namespace_path=namespace_path,
-                operation_groups=code_model.operation_groups,
-                filename="_operations"
-            )
-
 
     def _serialize_and_write_version_file(
         self, code_model: CodeModel, namespace_path: Path, general_serializer: GeneralSerializer