@autorest/python 5.12.4 → 5.13.0

package/autorest/codegen/models/parameter_list.py

@@ -207,7 +207,9 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
             lambda parameter: parameter.implementation == self.implementation
         )
         positional = [p for p in parameters_of_this_implementation if p.is_positional]
-        keyword_only = [p for p in parameters_of_this_implementation if p.is_keyword_only]
+        keyword_only = self._filter_out_multiple_content_type(
+            [p for p in parameters_of_this_implementation if p.is_keyword_only]
+        )
         kwargs = self._filter_out_multiple_content_type(
             [p for p in parameters_of_this_implementation if p.is_kwarg]
         )
@@ -275,6 +277,7 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
 def _create_files_or_data_param(
     params: List[Parameter], serialized_name: str, description: str
 ) -> Parameter:
+    params[0].need_import = False
     param = copy(params[0])
     param.serialized_name = serialized_name
     param.schema = DictionarySchema(
@@ -314,7 +317,9 @@ class ParameterOnlyPathAndBodyPositionalList(ParameterList):
             file_and_data_params.append(data_param)
         method_params = [p for p in method_params if not p.is_multipart and not p.is_data_input]
         positional = [p for p in method_params if p.is_positional]
-        keyword_only = [p for p in method_params if p.is_keyword_only]
+        keyword_only = self._filter_out_multiple_content_type(
+            [p for p in method_params if p.is_keyword_only]
+        )
         kwargs = self._filter_out_multiple_content_type(
             [p for p in method_params if p.is_kwarg]
         )
@@ -337,7 +342,9 @@ class GlobalParameterList(ParameterList):
         """
         # Client level should not be on Method, etc.
         positional = [p for p in self.parameters if p.is_positional]
-        keyword_only = [p for p in self.parameters if p.is_keyword_only]
+        keyword_only = self._filter_out_multiple_content_type(
+            [p for p in self.parameters if p.is_keyword_only]
+        )
         kwargs = self._filter_out_multiple_content_type(
             [p for p in self.parameters if p.is_kwarg]
         )
@@ -383,7 +390,7 @@ class GlobalParameterList(ParameterList):
             schema=StringSchema(namespace="", yaml_data={"type": "str"}),
             rest_api_name=self.host_variable_name,
             serialized_name=self.host_variable_name,
-            description=f"Service URL. Default value is '{host_value}'.",
+            description=f"Service URL.",
             implementation="Client",
             required=True,
             location=ParameterLocation.Other,

package/autorest/codegen/models/primitive_schemas.py

@@ -116,7 +116,7 @@ class IOSchema(PrimitiveSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
 class AnySchema(PrimitiveSchema):
@@ -138,7 +138,7 @@ class AnySchema(PrimitiveSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
 class JSONSchema(AnySchema):

package/autorest/codegen/models/property.py

@@ -170,5 +170,5 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def model_file_imports(self) -> FileImport:
         file_import = self.schema.model_file_imports()
         if not self.required:
-            file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import

package/autorest/codegen/models/request_builder.py

@@ -66,9 +66,10 @@ class RequestBuilder(BaseBuilder):
     def imports(self) -> FileImport:
         file_import = FileImport()
         for parameter in self.parameters:
-            file_import.merge(parameter.imports())
+            if parameter.need_import:
+                file_import.merge(parameter.imports())
 
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             "azure.core.rest",
             "HttpRequest",
             ImportType.AZURECORE,
@@ -77,17 +78,17 @@ class RequestBuilder(BaseBuilder):
             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_from_import(
+            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_from_import(
+            file_import.add_submodule_import(
                 "typing", "Dict", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
             )
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
-        file_import.add_from_import("msrest", "Serializer", ImportType.AZURECORE)
+        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"]

package/autorest/codegen/models/request_builder_parameter.py

@@ -62,6 +62,11 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
     def is_keyword_only(self) -> bool:
         return not self.location == ParameterLocation.Path and not self.is_kwarg
 
+    @is_keyword_only.setter
+    def is_keyword_only(self, val: bool) -> None:
+        self._keyword_only = val
+        self.is_kwarg = False
+
     @property
     def full_serialized_name(self) -> str:
         return self.serialized_name

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -198,6 +198,7 @@ class RequestBuilderParameterList(ParameterList):
         else:
             for kwarg in body_kwargs_added:
                 kwarg.required = False
+        first_body_param.need_import = False
         self.parameters = body_kwargs_added + self.parameters
 
     @property

package/autorest/codegen/models/schema_response.py

@@ -99,7 +99,7 @@ class SchemaResponse(BaseModel):
     def imports(self, code_model) -> FileImport:
         file_import = FileImport()
         if not code_model.options["models_mode"] and self.is_xml:
-            file_import.add_from_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")
+            file_import.add_submodule_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")
         return file_import
 
     @classmethod

package/autorest/codegen/serializers/__init__.py

@@ -30,10 +30,11 @@ __all__ = [
 ]
 
 class JinjaSerializer:
-    def __init__(self, autorestapi: AutorestAPI) -> None:
+    def __init__(self, autorestapi: AutorestAPI, code_model: CodeModel) -> None:
         self._autorestapi = autorestapi
+        self.code_model = code_model
 
-    def serialize(self, code_model: CodeModel) -> None:
+    def serialize(self) -> None:
         env = Environment(
             loader=PackageLoader("autorest.codegen", "templates"),
             keep_trailing_newline=True,
@@ -44,32 +45,34 @@ class JinjaSerializer:
         )
 
         namespace_path = (
-            Path(".") if code_model.options["no_namespace_folders"] else Path(*(code_model.namespace.split(".")))
+            Path(".")
+            if self.code_model.options["no_namespace_folders"]
+            else Path(*(self.code_model.namespace.split(".")))
         )
 
         # if there was a patch file before, we keep it
         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)
+        self._serialize_and_write_top_level_folder(env=env, namespace_path=namespace_path)
 
-        if code_model.rest.request_builders:
-            if code_model.options["builders_visibility"] != "embedded":
-                self._serialize_and_write_rest_layer(code_model=code_model, env=env, namespace_path=namespace_path)
-            if not code_model.options["no_async"]:
+        if self.code_model.rest.request_builders:
+            if self.code_model.options["builders_visibility"] != "embedded":
+                self._serialize_and_write_rest_layer(env=env, namespace_path=namespace_path)
+            if not self.code_model.options["no_async"]:
                 self._serialize_and_write_aio_top_level_folder(
-                    code_model=code_model, env=env, namespace_path=namespace_path,
+                    env=env, namespace_path=namespace_path,
                 )
 
-        if code_model.options["show_operations"] and code_model.operation_groups:
-            self._serialize_and_write_operations_folder(code_model=code_model, env=env, namespace_path=namespace_path)
-            if code_model.options["multiapi"]:
+        if self.code_model.options["show_operations"] and self.code_model.operation_groups:
+            self._serialize_and_write_operations_folder(env=env, namespace_path=namespace_path)
+            if self.code_model.options["multiapi"]:
                 self._serialize_and_write_metadata(
-                    code_model, env=env, namespace_path=namespace_path
+                    env=env, namespace_path=namespace_path
                 )
 
-        if code_model.options["models_mode"] and (code_model.schemas or code_model.enums):
-            self._serialize_and_write_models_folder(code_model=code_model, env=env, namespace_path=namespace_path)
+        if self.code_model.options["models_mode"] and (self.code_model.schemas or self.code_model.enums):
+            self._serialize_and_write_models_folder(env=env, namespace_path=namespace_path)
 
 
 
@@ -80,49 +83,51 @@ class JinjaSerializer:
             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:
+    def _serialize_and_write_models_folder(self, 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['python3_only']:
+        if self.code_model.schemas:
+            if not self.code_model.options['python3_only']:
                 self._autorestapi.write_file(
-                    models_path / Path("_models.py"), ModelGenericSerializer(code_model=code_model, env=env).serialize()
+                    models_path / Path("_models.py"),
+                    ModelGenericSerializer(code_model=self.code_model, env=env).serialize()
                 )
             self._autorestapi.write_file(
-                models_path / Path("_models_py3.py"), ModelPython3Serializer(code_model=code_model, env=env).serialize()
+                models_path / Path("_models_py3.py"),
+                ModelPython3Serializer(code_model=self.code_model, env=env).serialize()
             )
-        if code_model.enums:
+        if self.code_model.enums:
             self._autorestapi.write_file(
-                models_path / Path(f"_{code_model.module_name}_enums.py"),
-                EnumSerializer(code_model=code_model, env=env).serialize(),
+                models_path / Path(f"_{self.code_model.module_name}_enums.py"),
+                EnumSerializer(code_model=self.code_model, env=env).serialize(),
             )
         self._autorestapi.write_file(
-            models_path / Path("__init__.py"), ModelInitSerializer(code_model=code_model, env=env).serialize()
+            models_path / Path("__init__.py"), ModelInitSerializer(code_model=self.code_model, env=env).serialize()
         )
 
     def _serialize_and_write_rest_layer(
-        self, code_model: CodeModel, env: Environment, namespace_path: Path
+        self, env: Environment, namespace_path: Path
     ) -> None:
-        rest_path = namespace_path / Path(code_model.rest_layer_name)
+        rest_path = namespace_path / Path(self.code_model.rest_layer_name)
         operation_group_names = {
-            rb.operation_group_name for rb in code_model.rest.request_builders
+            rb.operation_group_name for rb in self.code_model.rest.request_builders
         }
 
         for operation_group_name in operation_group_names:
             request_builders = [
-                r for r in code_model.rest.request_builders if r.operation_group_name == operation_group_name
+                r for r in self.code_model.rest.request_builders if r.operation_group_name == operation_group_name
             ]
             self._serialize_and_write_single_rest_layer(
-                code_model, env, rest_path, request_builders
+                env, rest_path, request_builders
             )
         if not "" in operation_group_names:
             self._autorestapi.write_file(
-                rest_path / Path("__init__.py"), code_model.options['license_header']
+                rest_path / Path("__init__.py"), self.code_model.options['license_header']
             )
 
 
     def _serialize_and_write_single_rest_layer(
-        self, code_model: CodeModel, env: Environment, rest_path: Path, request_builders: List[RequestBuilder]
+        self, env: Environment, rest_path: Path, request_builders: List[RequestBuilder]
     ) -> None:
         builder_group_name = request_builders[0].builder_group_name
         output_path = rest_path / Path(builder_group_name) if builder_group_name else rest_path
@@ -130,7 +135,7 @@ class JinjaSerializer:
         self._autorestapi.write_file(
             output_path / Path("_request_builders.py"),
             RestGenericSerializer(
-                code_model=code_model, env=env, request_builders=request_builders
+                code_model=self.code_model, env=env, request_builders=request_builders
             ).serialize_request_builders()
         )
 
@@ -138,20 +143,19 @@ class JinjaSerializer:
         self._autorestapi.write_file(
             output_path / Path("_request_builders_py3.py"),
             RestPython3Serializer(
-                code_model=code_model, env=env, request_builders=request_builders
+                code_model=self.code_model, env=env, request_builders=request_builders
             ).serialize_request_builders()
         )
 
         # write rest init file
         self._autorestapi.write_file(
             output_path / Path("__init__.py"), RestSerializer(
-                code_model=code_model, env=env, request_builders=request_builders
+                code_model=self.code_model, env=env, request_builders=request_builders
             ).serialize_init()
         )
 
     def _serialize_and_write_operations_file(
         self,
-        code_model: CodeModel,
         env: Environment,
         namespace_path: Path,
         operation_group: Optional[OperationGroup] = None
@@ -159,35 +163,35 @@ class JinjaSerializer:
         filename = operation_group.filename if operation_group else "_operations"
         # write first sync file
         operation_group_serializer = OperationGroupsSerializer(
-            code_model=code_model,
+            code_model=self.code_model,
             env=env,
             async_mode=False,
-            is_python3_file=code_model.options['python3_only'],
+            is_python3_file=self.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"),
+            namespace_path / Path(self.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"]:
+        if not self.code_model.options['python3_only'] and self.code_model.options["add_python3_operation_files"]:
             # write typed second file if not python 3 only
             operation_group_serializer = OperationGroupsSerializer(
-                code_model=code_model,
+                code_model=self.code_model,
                 env=env,
                 async_mode=False,
                 is_python3_file=True,
 
             )
             self._autorestapi.write_file(
-                namespace_path / Path(code_model.operations_folder_name) / Path(f"{filename}_py3.py"),
+                namespace_path / Path(self.code_model.operations_folder_name) / Path(f"{filename}_py3.py"),
                 operation_group_serializer.serialize(),
             )
 
-        if not code_model.options["no_async"]:
+        if not self.code_model.options["no_async"]:
             # write async operation group and operation files
             operation_group_async_serializer = OperationGroupsSerializer(
-                code_model=code_model,
+                code_model=self.code_model,
                 env=env,
                 async_mode=True,
                 is_python3_file=True,
@@ -197,47 +201,47 @@ class JinjaSerializer:
                 (
                     namespace_path
                     / Path("aio")
-                    / Path(code_model.operations_folder_name)
+                    / Path(self.code_model.operations_folder_name)
                     / Path(f"{filename}.py")
                 ),
                 operation_group_async_serializer.serialize(),
             )
 
     def _serialize_and_write_operations_folder(
-        self, code_model: CodeModel, env: Environment, namespace_path: Path
+        self, env: Environment, namespace_path: Path
     ) -> None:
         # write sync operations init file
-        operations_init_serializer = OperationsInitSerializer(code_model=code_model, env=env, async_mode=False)
+        operations_init_serializer = OperationsInitSerializer(code_model=self.code_model, env=env, async_mode=False)
         self._autorestapi.write_file(
-            namespace_path / Path(code_model.operations_folder_name) / Path("__init__.py"),
+            namespace_path / Path(self.code_model.operations_folder_name) / Path("__init__.py"),
             operations_init_serializer.serialize(),
         )
 
         # write async operations init file
-        if not code_model.options["no_async"]:
-            operations_async_init_serializer = OperationsInitSerializer(code_model=code_model, env=env, async_mode=True)
+        if not self.code_model.options["no_async"]:
+            operations_async_init_serializer = OperationsInitSerializer(
+                code_model=self.code_model, env=env, async_mode=True
+            )
             self._autorestapi.write_file(
-                namespace_path / Path("aio") / Path(code_model.operations_folder_name) / Path("__init__.py"),
+                namespace_path / Path("aio") / Path(self.code_model.operations_folder_name) / Path("__init__.py"),
                 operations_async_init_serializer.serialize(),
             )
 
-        if code_model.options["combine_operation_files"]:
+        if self.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:
+            for operation_group in self.code_model.operation_groups:
                 self._serialize_and_write_operations_file(
-                    code_model=code_model,
                     env=env,
                     namespace_path=namespace_path,
                     operation_group=operation_group,
                 )
 
     def _serialize_and_write_version_file(
-        self, code_model: CodeModel, namespace_path: Path, general_serializer: GeneralSerializer
+        self, namespace_path: Path, general_serializer: GeneralSerializer
     ):
         def _read_version_file(original_version_file_name: str) -> str:
             return self._autorestapi.read_file(namespace_path / original_version_file_name)
@@ -247,23 +251,23 @@ class JinjaSerializer:
                 namespace_path / Path("_version.py"),
                 _read_version_file(original_version_file_name)
             )
-        keep_version_file = code_model.options['keep_version_file']
+        keep_version_file = self.code_model.options['keep_version_file']
         if keep_version_file and _read_version_file("_version.py"):
             _write_version_file(original_version_file_name="_version.py")
         elif keep_version_file and _read_version_file("version.py"):
             _write_version_file(original_version_file_name="version.py")
-        elif code_model.options['package_version']:
+        elif self.code_model.options['package_version']:
             self._autorestapi.write_file(
                 namespace_path / Path("_version.py"),
                 general_serializer.serialize_version_file()
             )
 
     def _serialize_and_write_top_level_folder(
-        self, code_model: CodeModel, env: Environment, namespace_path: Path
+        self, env: Environment, namespace_path: Path
     ) -> None:
-        general_serializer = GeneralSerializer(code_model=code_model, env=env, async_mode=False)
+        general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
 
-        if code_model.rest.request_builders:
+        if self.code_model.rest.request_builders:
             self._autorestapi.write_file(
                 namespace_path / Path("__init__.py"), general_serializer.serialize_init_file()
             )
@@ -280,37 +284,37 @@ class JinjaSerializer:
             p = p.parent
 
         # Write the service client
-        if code_model.rest.request_builders:
+        if self.code_model.rest.request_builders:
             self._autorestapi.write_file(
-                namespace_path / Path(f"_{code_model.module_name}.py"),
+                namespace_path / Path(f"_{self.code_model.module_name}.py"),
                 general_serializer.serialize_service_client_file()
             )
 
-        if code_model.need_vendored_code:
+        if self.code_model.need_vendored_code:
             self._autorestapi.write_file(
                 namespace_path / Path("_vendor.py"),
                 general_serializer.serialize_vendor_file()
             )
 
-        self._serialize_and_write_version_file(code_model, namespace_path, general_serializer)
+        self._serialize_and_write_version_file(namespace_path, general_serializer)
 
         # write the empty py.typed file
         self._autorestapi.write_file(namespace_path / Path("py.typed"), "# Marker file for PEP 561.")
 
         # Write the config file
-        if code_model.rest.request_builders:
+        if self.code_model.rest.request_builders:
             self._autorestapi.write_file(
                 namespace_path / Path("_configuration.py"), general_serializer.serialize_config_file()
             )
 
         # Write the setup file
-        if code_model.options["basic_setup_py"]:
+        if self.code_model.options["basic_setup_py"]:
             self._autorestapi.write_file(Path("setup.py"), general_serializer.serialize_setup_file())
 
     def _serialize_and_write_aio_top_level_folder(
-        self, code_model: CodeModel, env: Environment, namespace_path: Path
+        self, env: Environment, namespace_path: Path
     ) -> None:
-        aio_general_serializer = GeneralSerializer(code_model=code_model, env=env, async_mode=True)
+        aio_general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=True)
 
         aio_path = namespace_path / Path("aio")
 
@@ -319,7 +323,7 @@ class JinjaSerializer:
 
         # Write the service client
         self._autorestapi.write_file(
-            aio_path / Path(f"_{code_model.module_name}.py"),
+            aio_path / Path(f"_{self.code_model.module_name}.py"),
             aio_general_serializer.serialize_service_client_file(),
         )
 
@@ -329,6 +333,6 @@ class JinjaSerializer:
         )
 
 
-    def _serialize_and_write_metadata(self, code_model: CodeModel, env: Environment, namespace_path: Path) -> None:
-        metadata_serializer = MetadataSerializer(code_model, env)
+    def _serialize_and_write_metadata(self, env: Environment, namespace_path: Path) -> None:
+        metadata_serializer = MetadataSerializer(self.code_model, env)
         self._autorestapi.write_file(namespace_path / Path("_metadata.json"), metadata_serializer.serialize())