@autorest/python 6.1.11 → 6.2.0

package/autorest/codegen/models/operation.py

@@ -19,7 +19,6 @@ from typing import (
 from .request_builder_parameter import RequestBuilderParameter
 
 from .utils import OrderedSet, add_to_pylint_disable
-
 from .base_builder import BaseBuilder
 from .imports import FileImport, ImportType, TypingSection
 from .response import (
@@ -40,7 +39,8 @@ from .model_type import ModelType
 from .request_builder import OverloadedRequestBuilder, RequestBuilder
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
+    from .client import Client
 
 ResponseType = TypeVar(
     "ResponseType",
@@ -54,7 +54,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
+        client: "Client",
         name: str,
         request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
         parameters: ParameterList,
@@ -66,7 +67,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         want_tracing: bool = True,
     ) -> None:
         super().__init__(
-            code_model=code_model,
+            namespace_model=namespace_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             parameters=parameters,
@@ -96,7 +98,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
 
     def response_type_annotation(self, **kwargs) -> str:
         if (
-            self.code_model.options["head_as_boolean"]
+            self.namespace_model.options["head_as_boolean"]
             and self.request_builder.method.lower() == "head"
         ):
             return "bool"
@@ -125,7 +127,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def cls_type_annotation(self, *, async_mode: bool) -> str:
         if (
             self.request_builder.method.lower() == "head"
-            and self.code_model.options["head_as_boolean"]
+            and self.namespace_model.options["head_as_boolean"]
         ):
             return "ClsType[None]"
         return f"ClsType[{self.response_type_annotation(async_mode=async_mode)}]"
@@ -134,7 +136,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         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"]
+            and self.namespace_model.options["head_as_boolean"]
         ):
             return "bool"
         if responses_with_body:
@@ -152,9 +154,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
 
     def response_docstring_text(self, **kwargs) -> str:
         retval = self._response_docstring_helper("docstring_text", **kwargs)
-        if not self.code_model.options["version_tolerant"]:
+        if not self.namespace_model.options["version_tolerant"]:
             retval += " or the result of cls(response)"
-        if self.code_model.options["models_mode"] == "dpg" and any(
+        if self.namespace_model.options["models_mode"] == "dpg" and any(
             isinstance(r.type, ModelType) for r in self.responses
         ):
             r = next(r for r in self.responses if isinstance(r.type, ModelType))
@@ -233,7 +235,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.merge(
                 response.imports_for_multiapi(async_mode=async_mode, **kwargs)
             )
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             for exception in self.exceptions:
                 file_import.merge(
                     exception.imports_for_multiapi(async_mode=async_mode, **kwargs)
@@ -270,12 +272,12 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     ) -> FileImport:
         """Helper method to get a request builder import."""
         file_import = FileImport()
-        if self.code_model.options["builders_visibility"] != "embedded":
+        if self.namespace_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}",
+                    f"{rest_import_path}{self.namespace_model.rest_layer_name}",
                     group_name,
                     import_type=ImportType.LOCAL,
                     alias=f"rest_{group_name}",
@@ -283,13 +285,16 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             else:
                 file_import.add_submodule_import(
                     rest_import_path,
-                    self.code_model.rest_layer_name,
+                    self.namespace_model.rest_layer_name,
                     import_type=ImportType.LOCAL,
                     alias="rest",
                 )
-        if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
+        if (
+            self.namespace_model.options["builders_visibility"] == "embedded"
+            and async_mode
+        ):
             file_import.add_submodule_import(
-                f"...{self.code_model.operations_folder_name}.{self.filename}",
+                f"...{self.namespace_model.operations_folder_name}.{self.filename}",
                 request_builder.name,
                 import_type=ImportType.LOCAL,
             )
@@ -302,7 +307,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
 
         for response in self.responses:
             file_import.merge(response.imports(async_mode=async_mode, **kwargs))
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             for exception in self.exceptions:
                 file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
 
@@ -322,7 +327,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.add_submodule_import(
                 "azure.core.exceptions", error, ImportType.AZURECORE
             )
-        if self.code_model.options["azure_arm"]:
+        if self.namespace_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
             )
@@ -338,7 +343,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
-        if self.code_model.need_request_converter:
+        if self.namespace_model.need_request_converter:
             relative_path = "..." if async_mode else ".."
             file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
@@ -354,7 +359,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                 "azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE
             )
         if (
-            self.code_model.options["builders_visibility"] == "embedded"
+            self.namespace_model.options["builders_visibility"] == "embedded"
             and not async_mode
         ):
             file_import.merge(self.request_builder.imports())
@@ -376,7 +381,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         file_import.add_submodule_import(
             "typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if self.code_model.options["tracing"] and self.want_tracing and not async_mode:
+        if (
+            self.namespace_model.options["tracing"]
+            and self.want_tracing
+            and not async_mode
+        ):
             file_import.add_submodule_import(
                 f"azure.core.tracing.decorator",
                 f"distributed_trace",
@@ -409,11 +418,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         basename = self.group_name
         if basename == "":
             # in a mixin
-            basename = self.code_model.module_name
+            basename = self.namespace_model.clients[0].legacy_filename
 
         if (
             basename == "operations"
-            or self.code_model.options["combine_operation_files"]
+            or self.namespace_model.options["combine_operation_files"]
         ):
             return f"_operations"
         return f"_{basename}_operations"
@@ -423,25 +432,31 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         return any(r.is_stream_response for r in self.responses)
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        namespace_model: "NamespaceModel",
+        client: "Client",
+    ):
         name = yaml_data["name"]
-        request_builder = code_model.lookup_request_builder(id(yaml_data))
+        request_builder = namespace_model.lookup_request_builder(id(yaml_data))
         responses = [
-            cast(ResponseType, get_response(r, code_model))
+            cast(ResponseType, get_response(r, namespace_model))
             for r in yaml_data["responses"]
         ]
         exceptions = [
-            Response.from_yaml(e, code_model) for e in yaml_data["exceptions"]
+            Response.from_yaml(e, namespace_model) for e in yaml_data["exceptions"]
         ]
-        parameter_list = ParameterList.from_yaml(yaml_data, code_model)
+        parameter_list = ParameterList.from_yaml(yaml_data, namespace_model)
         overloads = [
-            cls.from_yaml(overload, code_model)
+            cls.from_yaml(overload, namespace_model, client)
             for overload in yaml_data.get("overloads", [])
         ]
 
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
+            namespace_model=namespace_model,
+            client=client,
             request_builder=request_builder,
             name=name,
             parameters=parameter_list,
@@ -466,10 +481,10 @@ class Operation(OperationBase[Response]):
         if (
             self.has_response_body
             and not self.has_optional_return_type
-            and not self.code_model.options["models_mode"]
+            and not self.namespace_model.options["models_mode"]
         ):
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
-        if self.code_model.options["models_mode"] == "dpg":
+        if self.namespace_model.options["models_mode"] == "dpg":
             relative_path = "..." if async_mode else ".."
             if self.parameters.has_body:
                 file_import.add_submodule_import(
@@ -486,7 +501,9 @@ class Operation(OperationBase[Response]):
         return file_import
 
 
-def get_operation(yaml_data: Dict[str, Any], code_model: "CodeModel") -> OperationBase:
+def get_operation(
+    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel", client: "Client"
+) -> OperationBase:
     if yaml_data["discriminator"] == "lropaging":
         from .lro_paging_operation import LROPagingOperation as OperationCls
     elif yaml_data["discriminator"] == "lro":
@@ -495,4 +512,4 @@ def get_operation(yaml_data: Dict[str, Any], code_model: "CodeModel") -> Operati
         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)
+    return OperationCls.from_yaml(yaml_data, namespace_model, client)

package/autorest/codegen/models/operation_group.py

@@ -13,7 +13,8 @@ from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_pylint_disable
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
+    from .client import Client
 
 
 class OperationGroup(BaseModel):
@@ -22,11 +23,13 @@ class OperationGroup(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
+        client: "Client",
         operations: List[OperationBase],
         api_versions: List[str],
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
+        self.client = client
         self.class_name: str = yaml_data["className"]
         self.property_name: str = yaml_data["propertyName"]
         self.operations = operations
@@ -39,8 +42,8 @@ class OperationGroup(BaseModel):
     @property
     def base_class(self) -> str:
         base_classes: List[str] = []
-        if self.is_mixin and self.code_model.need_mixin_abc:
-            base_classes.append("MixinABC")
+        if self.is_mixin and self.namespace_model.need_mixin_abc:
+            base_classes.append(f"{self.client.name}MixinABC")
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
@@ -81,13 +84,15 @@ class OperationGroup(BaseModel):
             )
         # for multiapi
         if (
-            self.code_model.model_types or self.code_model.enums
-        ) and self.code_model.options["models_mode"] == "msrest":
+            self.namespace_model.model_types or self.namespace_model.enums
+        ) and self.namespace_model.options["models_mode"] == "msrest":
             file_import.add_submodule_import(
                 relative_path, "models", ImportType.LOCAL, alias="_models"
             )
-        if self.code_model.need_mixin_abc:
-            file_import.add_submodule_import(".._vendor", "MixinABC", ImportType.LOCAL)
+        if self.namespace_model.need_mixin_abc:
+            file_import.add_submodule_import(
+                ".._vendor", f"{self.client.name}MixinABC", ImportType.LOCAL
+            )
         if self.has_abstract_operations:
             file_import.add_submodule_import(
                 ".._vendor", "raise_if_not_implemented", ImportType.LOCAL
@@ -115,16 +120,22 @@ class OperationGroup(BaseModel):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls,
+        yaml_data: Dict[str, Any],
+        namespace_model: "NamespaceModel",
+        client: "Client",
     ) -> "OperationGroup":
-        operations = [get_operation(o, code_model) for o in yaml_data["operations"]]
+        operations = [
+            get_operation(o, namespace_model, client) for o in yaml_data["operations"]
+        ]
         api_versions: OrderedSet[str] = {}
         for operation in operations:
             for api_version in operation.api_versions:
                 api_versions[api_version] = None
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
+            namespace_model=namespace_model,
+            client=client,
             operations=operations,
             api_versions=list(api_versions.keys()),
         )

package/autorest/codegen/models/paging_operation.py

@@ -17,7 +17,8 @@ from .parameter_list import ParameterList
 from .model_type import ModelType
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
+    from .client import Client
 
 PagingResponseType = TypeVar(
     "PagingResponseType", bound=Union[PagingResponse, LROPagingResponse]
@@ -28,7 +29,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
+        client: "Client",
         name: str,
         request_builder: RequestBuilder,
         parameters: ParameterList,
@@ -41,7 +43,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         override_success_response_to_200: bool = False,
     ) -> None:
         super().__init__(
-            code_model=code_model,
+            namespace_model=namespace_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             request_builder=request_builder,
@@ -55,7 +58,9 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self.next_request_builder: Optional[
             Union[RequestBuilder, OverloadedRequestBuilder]
         ] = (
-            get_request_builder(self.yaml_data["nextOperation"], code_model)
+            get_request_builder(
+                self.yaml_data["nextOperation"], namespace_model, client
+            )
             if self.yaml_data.get("nextOperation")
             else None
         )
@@ -85,14 +90,14 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         if not rest_api_name:
             # That's an ok scenario, it just means no next page possible
             return None
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
     @property
     def item_name(self) -> str:
         rest_api_name = self.yaml_data["itemName"]
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
@@ -115,7 +120,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             )
         if (
             self.next_request_builder
-            and self.code_model.options["builders_visibility"] == "embedded"
+            and self.namespace_model.options["builders_visibility"] == "embedded"
             and not async_mode
         ):
             file_import.merge(self.next_request_builder.imports())
@@ -130,7 +135,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
-        if self.code_model.options["tracing"] and self.want_tracing:
+        if self.namespace_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator",
                 "distributed_trace",
@@ -140,9 +145,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             file_import.merge(
                 self.get_request_builder_import(self.next_request_builder, async_mode)
             )
-        elif "api-version" in [
-            p.rest_api_name for p in self.code_model.client.parameters
-        ]:
+        elif "api-version" in [p.rest_api_name for p in self.client.parameters]:
             file_import.add_import("urllib.parse", ImportType.STDLIB)
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE

package/autorest/codegen/models/parameter.py

@@ -27,7 +27,7 @@ from .combined_type import CombinedType
 from .utils import add_to_description
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
     from .request_builder_parameter import RequestBuilderBodyParameter
 
 
@@ -61,10 +61,10 @@ class _ParameterBase(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.rest_api_name: str = yaml_data["restApiName"]
         self.client_name: str = self.yaml_data["clientName"]
         self.optional: bool = self.yaml_data["optional"]
@@ -230,18 +230,18 @@ class BodyParameter(_BodyParameterBase):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "BodyParameter":
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
+            namespace_model=namespace_model,
+            type=namespace_model.lookup_type(id(yaml_data["type"])),
         )
 
     def type_annotation(self, **kwargs: Any) -> str:
         annotation = super().type_annotation(**kwargs)
         model_seq = BodyParameter.get_model_seq(self.type)
-        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
+        if self.namespace_model.options["models_mode"] == "dpg" and model_seq >= 0:
             pattern = re.compile(r"Union\[.*\]")
             union_content = (
                 annotation[6:-1] if pattern.match(annotation) else annotation
@@ -254,7 +254,7 @@ class BodyParameter(_BodyParameterBase):
     def docstring_type(self, **kwargs: Any) -> str:
         docstring = super().docstring_type(**kwargs)
         model_seq = BodyParameter.get_model_seq(self.type)
-        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
+        if self.namespace_model.options["models_mode"] == "dpg" and model_seq >= 0:
             items = docstring.split(" or ")
             items.insert(model_seq + 1, "JSON")
             docstring = " or ".join(items)
@@ -284,11 +284,11 @@ class _MultipartBodyParameter(Generic[EntryBodyParameterType], BodyParameter):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         type: BaseType,
         entries: List[EntryBodyParameterType],
     ) -> None:
-        super().__init__(yaml_data, code_model, type)
+        super().__init__(yaml_data, namespace_model, type)
         self.entries = entries
 
     @property
@@ -305,14 +305,14 @@ class MultipartBodyParameter(
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "MultipartBodyParameter":
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
+            namespace_model=namespace_model,
+            type=namespace_model.lookup_type(id(yaml_data["type"])),
             entries=[
-                BodyParameter.from_yaml(entry, code_model)
+                BodyParameter.from_yaml(entry, namespace_model)
                 for entry in yaml_data["entries"]
             ],
         )
@@ -324,10 +324,10 @@ class Parameter(_ParameterBase):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, code_model, type=type)
+        super().__init__(yaml_data, namespace_model, type=type)
 
         self.implementation: str = yaml_data["implementation"]
         self.skip_url_encoding: bool = self.yaml_data.get("skipUrlEncoding", False)
@@ -371,18 +371,18 @@ class Parameter(_ParameterBase):
             ParameterLocation.QUERY,
         )
         if (
-            self.code_model.options["only_path_and_body_params_positional"]
+            self.namespace_model.options["only_path_and_body_params_positional"]
             and query_or_header
         ):
             return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+    def from_yaml(cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"):
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
+            namespace_model=namespace_model,
+            type=namespace_model.lookup_type(id(yaml_data["type"])),
         )
 
 
@@ -398,8 +398,8 @@ class ClientParameter(Parameter):
         if self.constant:
             return ParameterMethodLocation.KWARG
         if self.is_host and (
-            self.code_model.options["version_tolerant"]
-            or self.code_model.options["low_level_client"]
+            self.namespace_model.options["version_tolerant"]
+            or self.namespace_model.options["low_level_client"]
         ):
             # this means i am the base url
             return ParameterMethodLocation.KEYWORD_ONLY
@@ -425,9 +425,9 @@ class ConfigParameter(Parameter):
 
 
 def get_body_parameter(
-    yaml_data: Dict[str, Any], code_model: "CodeModel"
+    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
 ) -> Union[BodyParameter, MultipartBodyParameter]:
     """Creates a regular body parameter or Multipart body parameter"""
     if yaml_data.get("entries"):
-        return MultipartBodyParameter.from_yaml(yaml_data, code_model)
-    return BodyParameter.from_yaml(yaml_data, code_model)
+        return MultipartBodyParameter.from_yaml(yaml_data, namespace_model)
+    return BodyParameter.from_yaml(yaml_data, namespace_model)