@autorest/python 5.15.0 → 5.16.0

package/autorest/codegen/models/primitive_schemas.py

@@ -6,21 +6,24 @@
 import logging
 import datetime
 from enum import Enum
-from typing import cast, Any, Dict, List, Optional, Union
+from typing import cast, Any, Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base_schema import BaseSchema
 from .imports import FileImport, ImportType, TypingSection
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class RawString(object):
     def __init__(self, string: str) -> None:
         self.string = string
 
     def __repr__(self) -> str:
-        return "r'{}'".format(self.string.replace('\'', '\\\''))
-
+        return "r'{}'".format(self.string.replace("'", "\\'"))
 
 
 class PrimitiveSchema(BaseSchema):
@@ -39,7 +42,9 @@ class PrimitiveSchema(BaseSchema):
     def docstring_type(self) -> str:
         return self._to_python_type()
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return self.docstring_type
 
     @property
@@ -69,28 +74,18 @@ class PrimitiveSchema(BaseSchema):
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         if self.default_value:
             kwargs["default_value_declaration"] = kwargs.get(
-                "default_value_declaration",
-                self.get_declaration(self.default_value)
+                "default_value_declaration", self.get_declaration(self.default_value)
             )
-        return self._add_optional_and_default_value_template_representation(
-            **kwargs
-        )
+        return self._add_optional_and_default_value_template_representation(**kwargs)
 
     @property
     def default_template_representation_declaration(self) -> str:
         return self.get_declaration(self.docstring_type)
 
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        """Template of what the files input should look like
-        """
-        return self._add_optional_and_default_value_template_representation(
-            **kwargs
-        )
 
 class IOSchema(PrimitiveSchema):
-
-    def __init__(self, namespace, yaml_data) -> None:
-        super(IOSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.type = "IO"
 
     @property
@@ -101,7 +96,9 @@ class IOSchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return self.type
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return self.docstring_type
 
     @property
@@ -114,9 +111,12 @@ class IOSchema(PrimitiveSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
         return file_import
 
+
 class AnySchema(PrimitiveSchema):
     @property
     def serialization_type(self) -> str:
@@ -126,7 +126,9 @@ class AnySchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return "any"
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "Any"
 
     @property
@@ -135,22 +137,15 @@ class AnySchema(PrimitiveSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
         return file_import
 
-class JSONSchema(AnySchema):
-
-    @property
-    def docstring_type(self) -> str:
-        return "JSONType"
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
-        return "JSONType"
-
 
 class NumberSchema(PrimitiveSchema):
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(NumberSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.precision = cast(int, yaml_data["precision"])
         self.multiple = cast(int, yaml_data.get("multipleOf"))
         self.maximum = cast(int, yaml_data.get("maximum"))
@@ -161,10 +156,18 @@ class NumberSchema(PrimitiveSchema):
     @property
     def serialization_constraints(self) -> List[str]:
         validation_constraints = [
-            f"maximum_ex={self.maximum}" if self.maximum is not None and self.exclusive_maximum else None,
-            f"maximum={self.maximum}" if self.maximum is not None and not self.exclusive_maximum else None,
-            f"minimum_ex={self.minimum}" if self.minimum is not None and self.exclusive_minimum else None,
-            f"minimum={self.minimum}" if self.minimum is not None and not self.exclusive_minimum else None,
+            f"maximum_ex={self.maximum}"
+            if self.maximum is not None and self.exclusive_maximum
+            else None,
+            f"maximum={self.maximum}"
+            if self.maximum is not None and not self.exclusive_maximum
+            else None,
+            f"minimum_ex={self.minimum}"
+            if self.minimum is not None and self.exclusive_minimum
+            else None,
+            f"minimum={self.minimum}"
+            if self.minimum is not None and not self.exclusive_minimum
+            else None,
             f"multiple={self.multiple}" if self.multiple else None,
         ]
         return [x for x in validation_constraints if x is not None]
@@ -202,7 +205,9 @@ class NumberSchema(PrimitiveSchema):
             return "int"
         return "float"
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         python_type = self.docstring_type
         if python_type == "long":
             return "int"
@@ -213,13 +218,18 @@ class NumberSchema(PrimitiveSchema):
         default_value = 0 if self.docstring_type == "int" else 0.0
         return self.get_declaration(default_value)
 
-class StringSchema(PrimitiveSchema):
 
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(StringSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+class StringSchema(PrimitiveSchema):
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.max_length = cast(int, yaml_data.get("maxLength"))
         self.min_length = cast(
-            int, (yaml_data.get("minLength", 0) if yaml_data.get("maxLength") else yaml_data.get("minLength"))
+            int,
+            (
+                yaml_data.get("minLength", 0)
+                if yaml_data.get("maxLength")
+                else yaml_data.get("minLength")
+            ),
         )
         self.pattern = cast(str, yaml_data.get("pattern"))
 
@@ -249,8 +259,8 @@ class StringSchema(PrimitiveSchema):
 
 
 class DatetimeSchema(PrimitiveSchema):
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(DatetimeSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.format = self.Formats(yaml_data["format"])
 
     class Formats(str, Enum):
@@ -259,14 +269,19 @@ class DatetimeSchema(PrimitiveSchema):
 
     @property
     def serialization_type(self) -> str:
-        formats_to_attribute_type = {self.Formats.datetime: "iso-8601", self.Formats.rfc1123: "rfc-1123"}
+        formats_to_attribute_type = {
+            self.Formats.datetime: "iso-8601",
+            self.Formats.rfc1123: "rfc-1123",
+        }
         return formats_to_attribute_type[self.format]
 
     @property
     def docstring_type(self) -> str:
         return "~" + self.type_annotation()
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.datetime"
 
     @property
@@ -288,6 +303,7 @@ class DatetimeSchema(PrimitiveSchema):
     def default_template_representation_declaration(self):
         return self.get_declaration(datetime.datetime(2020, 2, 20))
 
+
 class TimeSchema(PrimitiveSchema):
     @property
     def serialization_type(self) -> str:
@@ -297,7 +313,9 @@ class TimeSchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return "~" + self.type_annotation()
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.time"
 
     @property
@@ -329,7 +347,9 @@ class UnixTimeSchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return "~" + self.type_annotation()
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.datetime"
 
     @property
@@ -361,7 +381,9 @@ class DateSchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return "~" + self.type_annotation()
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.date"
 
     @property
@@ -393,7 +415,9 @@ class DurationSchema(PrimitiveSchema):
     def docstring_type(self) -> str:
         return "~" + self.type_annotation()
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "datetime.timedelta"
 
     @property
@@ -417,8 +441,8 @@ class DurationSchema(PrimitiveSchema):
 
 
 class ByteArraySchema(PrimitiveSchema):
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super(ByteArraySchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.format = self.Formats(yaml_data["format"])
 
     class Formats(str, Enum):
@@ -443,7 +467,9 @@ class ByteArraySchema(PrimitiveSchema):
         return f'bytearray("{value}", encoding="utf-8")'
 
 
-def get_primitive_schema(namespace: str, yaml_data: Dict[str, Any]) -> "PrimitiveSchema":
+def get_primitive_schema(
+    yaml_data: Dict[str, Any], code_model: "CodeModel"
+) -> "PrimitiveSchema":
     mapping = {
         "integer": NumberSchema,
         "number": NumberSchema,
@@ -457,10 +483,13 @@ def get_primitive_schema(namespace: str, yaml_data: Dict[str, Any]) -> "Primitiv
         "byte-array": ByteArraySchema,
         "any": AnySchema,
         "any-object": AnySchema,
-        "binary": IOSchema
+        "binary": IOSchema,
     }
     schema_type = yaml_data["type"]
     primitive_schema = cast(
-        PrimitiveSchema, mapping.get(schema_type, PrimitiveSchema).from_yaml(namespace=namespace, yaml_data=yaml_data)
+        PrimitiveSchema,
+        mapping.get(schema_type, PrimitiveSchema).from_yaml(
+            yaml_data=yaml_data, code_model=code_model
+        ),
     )
     return primitive_schema

package/autorest/codegen/models/property.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import cast, Any, Dict, Union, List, Optional
+from typing import cast, Any, Dict, Union, List, Optional, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .constant_schema import ConstantSchema
@@ -11,19 +11,24 @@ from .imports import FileImport, ImportType, TypingSection
 from .base_schema import BaseSchema
 from .enum_schema import EnumSchema
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
 class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
         schema: BaseSchema,
         original_swagger_name: str,
         *,
         flattened_names: Optional[List[str]] = None,
         description: Optional[str] = None,
-        client_default_value: Optional[Any] = None
+        client_default_value: Optional[Any] = None,
     ) -> None:
-        super().__init__(yaml_data)
+        super().__init__(yaml_data, code_model)
         self.name = name
         self.schema = schema
         self.original_swagger_name = original_swagger_name
@@ -35,15 +40,18 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.client_default_value = client_default_value
         self.description = self._create_description(description, yaml_data)
 
-
-    def _create_description(self, description_input: Optional[str], yaml_data: Dict[str, Any]) -> str:
-        description: str = description_input or yaml_data["language"]["python"]["description"]
+    def _create_description(
+        self, description_input: Optional[str], yaml_data: Dict[str, Any]
+    ) -> str:
+        description: str = (
+            description_input or yaml_data["language"]["python"]["description"]
+        )
         if description and description[-1] != ".":
             description += "."
         if self.name == "tags":
             description = "A set of tags. " + description
         if self.constant:
-            description += f' Has constant value: {self.constant_declaration}.'
+            description += f" Has constant value: {self.constant_declaration}."
         elif self.required:
             if description:
                 description = "Required. " + description
@@ -51,13 +59,16 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 description = "Required. "
         elif isinstance(self.schema, ConstantSchema):
             description += (
-                f" The only acceptable values to pass in are None and {self.constant_declaration}. " +
-                f"The default value is {self.default_value_declaration}."
+                f" The only acceptable values to pass in are None and {self.constant_declaration}. "
+                + f"The default value is {self.default_value_declaration}."
             )
         if self.is_discriminator:
             description += "Constant filled by server. "
         if isinstance(self.schema, EnumSchema):
-            values = [self.schema.enum_type.get_declaration(v.value) for v in self.schema.values]
+            values = [
+                self.schema.enum_type.get_declaration(v.value)
+                for v in self.schema.values
+            ]
             if description and description[-1] != " ":
                 description += " "
             description += "Known values are: {}.".format(", ".join(values))
@@ -70,9 +81,9 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         # this bool doesn't consider you to be constant if you are a discriminator
         # you also have to be required to be considered a constant
         return (
-            isinstance(self.schema, ConstantSchema) and
-            self.required and
-            not self.is_discriminator
+            isinstance(self.schema, ConstantSchema)
+            and self.required
+            and not self.is_discriminator
         )
 
     @property
@@ -85,29 +96,36 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.constant:
             retval["constant"] = True
         if self.schema.validation_map:
-            validation_map_from_schema = cast(Dict[str, Union[bool, int, str]], self.schema.validation_map)
+            validation_map_from_schema = cast(
+                Dict[str, Union[bool, int, str]], self.schema.validation_map
+            )
             retval.update(validation_map_from_schema)
         return retval or None
 
     @property
     def escaped_swagger_name(self) -> str:
-        """Return the RestAPI name correctly escaped for serialization.
-        """
+        """Return the RestAPI name correctly escaped for serialization."""
         if self.flattened_names:
             return ".".join(n.replace(".", "\\\\.") for n in self.flattened_names)
         return self.original_swagger_name.replace(".", "\\\\.")
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], **kwargs) -> "Property":
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        *,
+        has_additional_properties: Optional[bool] = None,
+    ) -> "Property":
         from . import build_schema  # pylint: disable=import-outside-toplevel
 
         name = yaml_data["language"]["python"]["name"]
-        has_additional_properties = kwargs.pop("has_additional_properties", None)
         if name == "additional_properties" and has_additional_properties:
             name = "additional_properties1"
-        schema = build_schema(yaml_data=yaml_data["schema"], **kwargs)
+        schema = build_schema(yaml_data=yaml_data["schema"], code_model=code_model)
         return cls(
             yaml_data=yaml_data,
+            code_model=code_model,
             name=name,
             schema=schema,
             original_swagger_name=yaml_data["serializedName"],
@@ -126,7 +144,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 return self.schema.get_declaration(self.schema.value)
             raise ValueError(
                 "Trying to get constant declaration for a schema that is not ConstantSchema"
-                )
+            )
         raise ValueError("Trying to get a declaration for a schema that doesn't exist")
 
     @property
@@ -157,18 +175,18 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         kwargs["optional"] = not self.required
         if self.default_value:
-            kwargs["default_value_declaration"] = self.schema.get_declaration(self.default_value)
+            kwargs["default_value_declaration"] = self.schema.get_declaration(
+                self.default_value
+            )
         if self.description:
             kwargs["description"] = self.description
         return self.schema.get_json_template_representation(**kwargs)
 
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        kwargs["optional"] = not self.required
-        return self.schema.get_files_and_data_template_representation(**kwargs)
-
     def model_file_imports(self) -> FileImport:
         file_import = self.schema.model_file_imports()
         if not self.required:
-            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import(
+                "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
         file_import.merge(self.schema.model_file_imports())
         return file_import

package/autorest/codegen/models/request_builder.py

@@ -3,7 +3,8 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, TypeVar, Optional
+from typing import Any, Dict, List, TypeVar, Optional, TYPE_CHECKING
+import logging
 
 from .base_builder import BaseBuilder, create_parameters
 from .request_builder_parameter import RequestBuilderParameter
@@ -13,15 +14,20 @@ from .schema_response import SchemaResponse
 from .imports import FileImport, ImportType, TypingSection
 from .parameter import Parameter
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
-T = TypeVar('T')
+_LOGGER = logging.getLogger(__name__)
+
+T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+
 class RequestBuilder(BaseBuilder):
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
         url: str,
         method: str,
@@ -31,16 +37,20 @@ class RequestBuilder(BaseBuilder):
         description: str,
         summary: str,
         responses: Optional[List[SchemaResponse]] = None,
+        *,
+        abstract: bool = False,
     ):
         super().__init__(
-            code_model=code_model,
             yaml_data=yaml_data,
+            code_model=code_model,
             name=name,
             description=description,
             parameters=parameters,
             responses=responses,
             schema_requests=schema_requests,
             summary=summary,
+            abstract=abstract,
+            want_tracing=False,
         )
         self.url = url
         self.method = method
@@ -65,62 +75,86 @@ class RequestBuilder(BaseBuilder):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        for parameter in self.parameters:
-            if parameter.need_import:
-                file_import.merge(parameter.imports())
+        for parameter in self.parameters.method:
+            if self.abstract and (parameter.is_multipart or parameter.is_data_input):
+                continue
+            file_import.merge(parameter.imports())
 
         file_import.add_submodule_import(
             "azure.core.rest",
             "HttpRequest",
             ImportType.AZURECORE,
         )
-        if self.parameters.path:
-            relative_path = ".."
-            if not self.code_model.options["builders_visibility"] == "embedded" and self.operation_group_name:
-                relative_path = "..." if self.operation_group_name else ".."
-            file_import.add_submodule_import(
-                f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
-            )
-        if self.parameters.headers or self.parameters.query:
-            file_import.add_submodule_import("azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE)
+        if not self.abstract:
+            if self.parameters.path:
+                relative_path = ".."
+                if (
+                    not self.code_model.options["builders_visibility"] == "embedded"
+                    and self.operation_group_name
+                ):
+                    relative_path = "..." if self.operation_group_name else ".."
+                file_import.add_submodule_import(
+                    f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
+                )
+            if self.parameters.headers or self.parameters.query:
+                file_import.add_submodule_import(
+                    "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+                )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
-        if self.parameters.has_body and (
-            self.code_model.options["builders_visibility"] != "embedded" or
-            self.code_model.options["add_python3_operation_files"]
-        ):
-            file_import.define_mypy_type("JSONType", "Any")
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "RequestBuilder":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "RequestBuilder":
 
         # when combine embeded builders into one operation file, we need to avoid duplicated build function name.
         # So add operation group name is effective method
         additional_mark = ""
-        if code_model.options["combine_operation_files"] and code_model.options["builders_visibility"] == "embedded":
+        if (
+            code_model.options["combine_operation_files"]
+            and code_model.options["builders_visibility"] == "embedded"
+        ):
             additional_mark = yaml_data["language"]["python"]["builderGroupName"]
         names = [
             "build",
             additional_mark,
             yaml_data["language"]["python"]["name"],
-            "request"
+            "request",
         ]
         name = "_".join([n for n in names if n])
 
         first_request = yaml_data["requests"][0]
-        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, RequestBuilderParameter.from_yaml)
+        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, RequestBuilderParameter.from_yaml
         )
         parameter_list = RequestBuilderParameterList(
             code_model, parameters + multiple_content_type_parameters, schema_requests
         )
+        abstract = False
+        if (
+            code_model.options["version_tolerant"]
+            or code_model.options["low_level_client"]
+        ) and any(p for p in parameter_list if p.is_multipart or p.is_data_input):
+            _LOGGER.warning(
+                'Not going to generate request_builder "%s" because it has multipart / urlencoded '
+                "body parameters. Multipart / urlencoded body parameters are not supported for version "
+                "tolerant and low level generations 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
+
         request_builder_class = cls(
-            code_model=code_model,
             yaml_data=yaml_data,
+            code_model=code_model,
             name=name,
             url=first_request["protocol"]["http"]["path"],
             method=first_request["protocol"]["http"]["method"].upper(),
@@ -129,10 +163,11 @@ class RequestBuilder(BaseBuilder):
             parameters=parameter_list,
             description=yaml_data["language"]["python"]["description"],
             responses=[
-                SchemaResponse.from_yaml(yaml, code_model=code_model) for yaml in yaml_data.get("responses", [])
+                SchemaResponse.from_yaml(yaml, code_model=code_model)
+                for yaml in yaml_data.get("responses", [])
             ],
             summary=yaml_data["language"]["python"].get("summary"),
+            abstract=abstract,
         )
-        code_model.request_builder_ids[id(yaml_data)] = request_builder_class
         parameter_list.add_body_kwargs()
         return request_builder_class