@autorest/python 6.13.16 → 6.13.18

package/autorest/codegen/models/operation_group.py

@@ -49,15 +49,13 @@ class OperationGroup(BaseModel):
     @property
     def has_abstract_operations(self) -> bool:
         return any(o for o in self.operations if o.abstract) or any(
-            operation_group.has_abstract_operations
-            for operation_group in self.operation_groups
+            operation_group.has_abstract_operations for operation_group in self.operation_groups
         )
 
     @property
     def has_non_abstract_operations(self) -> bool:
         return any(o for o in self.operations if not o.abstract) or any(
-            operation_group.has_non_abstract_operations
-            for operation_group in self.operation_groups
+            operation_group.has_non_abstract_operations for operation_group in self.operation_groups
         )
 
     @property
@@ -71,15 +69,11 @@ class OperationGroup(BaseModel):
         file_import = FileImport(self.code_model)
         relative_path = ".." if async_mode else "."
         for operation in self.operations:
-            file_import.merge(
-                operation.imports_for_multiapi(async_mode, relative_path=relative_path)
-            )
-        if (
-            self.code_model.model_types or self.code_model.enums
-        ) and self.code_model.options["models_mode"] == "msrest":
-            file_import.add_submodule_import(
-                relative_path, "models", ImportType.LOCAL, alias="_models"
-            )
+            file_import.merge(operation.imports_for_multiapi(async_mode, relative_path=relative_path))
+        if (self.code_model.model_types or self.code_model.enums) and self.code_model.options[
+            "models_mode"
+        ] == "msrest":
+            file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
         return file_import
 
     @property
@@ -103,13 +97,9 @@ class OperationGroup(BaseModel):
     def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport(self.code_model)
 
-        relative_path = ("..." if async_mode else "..") + (
-            "." if self.client.is_subclient else ""
-        )
+        relative_path = ("..." if async_mode else "..") + ("." if self.client.is_subclient else "")
         for operation in self.operations:
-            file_import.merge(
-                operation.imports(async_mode, relative_path=relative_path)
-            )
+            file_import.merge(operation.imports(async_mode, relative_path=relative_path))
         if not self.code_model.options["combine_operation_files"]:
             for og in self.operation_groups:
                 file_import.add_submodule_import(
@@ -123,27 +113,17 @@ class OperationGroup(BaseModel):
             and self.code_model.options["models_mode"] == "msrest"
             and not self.is_mixin
         ):
-            file_import.add_submodule_import(
-                relative_path, "models", ImportType.LOCAL, alias="_models"
-            )
+            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", f"{self.client.name}MixinABC", ImportType.LOCAL
-            )
+            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
-            )
+            file_import.add_submodule_import(".._vendor", "raise_if_not_implemented", ImportType.LOCAL)
         if all(o.abstract for o in self.operations):
             return file_import
-        file_import.add_submodule_import(
-            "typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
+        file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.define_mypy_type("T", "TypeVar('T')")
         type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, Dict[str, Any]], Any]]"
-        file_import.define_mypy_type(
-            "ClsType", type_value.format(""), type_value.format("Async")
-        )
+        file_import.define_mypy_type("ClsType", type_value.format(""), type_value.format("Async"))
         return file_import
 
     @property
@@ -160,44 +140,27 @@ class OperationGroup(BaseModel):
         for operation_group in self.operation_groups:
             for operation in operation_group.operations:
                 if isinstance(operation, (LROOperation, LROPagingOperation)):
-                    operation.initial_operation = self.lookup_operation(
-                        id(operation.yaml_data["initialOperation"])
-                    )
+                    operation.initial_operation = self.lookup_operation(id(operation.yaml_data["initialOperation"]))
 
     def lookup_operation(self, operation_id: int) -> "OperationType":
         try:
-            return next(
-                o
-                for og in self.operation_groups
-                for o in og.operations
-                if id(o.yaml_data) == operation_id
-            )
+            return next(o for og in self.operation_groups for o in og.operations if id(o.yaml_data) == operation_id)
         except StopIteration as exc:
             raise KeyError(f"No operation with id {operation_id} found.") from exc
 
     @property
     def lro_operations(self) -> List["OperationType"]:
-        return [
-            operation
-            for operation in self.operations
-            if operation.operation_type in ("lro", "lropaging")
-        ] + [
-            operation
-            for operation_group in self.operation_groups
-            for operation in operation_group.lro_operations
+        return [operation for operation in self.operations if operation.operation_type in ("lro", "lropaging")] + [
+            operation for operation_group in self.operation_groups for operation in operation_group.lro_operations
         ]
 
     @property
     def has_operations(self) -> bool:
-        return any(
-            operation_group.has_operations for operation_group in self.operation_groups
-        ) or bool(self.operations)
+        return any(operation_group.has_operations for operation_group in self.operation_groups) or bool(self.operations)
 
     @property
     def has_form_data_body(self) -> bool:
-        operations = self.operations + [
-            o for og in self.operation_groups for o in og.operations
-        ]
+        operations = self.operations + [o for og in self.operation_groups for o in og.operations]
         return any(operation.has_form_data_body for operation in operations)
 
     @classmethod
@@ -207,9 +170,7 @@ class OperationGroup(BaseModel):
         code_model: "CodeModel",
         client: "Client",
     ) -> "OperationGroup":
-        operations = [
-            get_operation(o, code_model, client) for o in yaml_data["operations"]
-        ]
+        operations = [get_operation(o, code_model, client) for o in yaml_data["operations"]]
         api_versions: OrderedSet[str] = {}
         for operation in operations:
             for api_version in operation.api_versions:

package/autorest/codegen/models/paging_operation.py

@@ -22,9 +22,7 @@ if TYPE_CHECKING:
     from .code_model import CodeModel
     from .client import Client
 
-PagingResponseType = TypeVar(
-    "PagingResponseType", bound=Union[PagingResponse, LROPagingResponse]
-)
+PagingResponseType = TypeVar("PagingResponseType", bound=Union[PagingResponse, LROPagingResponse])
 
 
 class PagingOperationBase(OperationBase[PagingResponseType]):
@@ -53,41 +51,25 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             exceptions=exceptions,
             overloads=overloads,
         )
-        self.next_request_builder: Optional[
-            Union[RequestBuilder, OverloadedRequestBuilder]
-        ] = (
+        self.next_request_builder: Optional[Union[RequestBuilder, OverloadedRequestBuilder]] = (
             get_request_builder(self.yaml_data["nextOperation"], code_model, client)
             if self.yaml_data.get("nextOperation")
             else None
         )
         self.override_success_response_to_200 = override_success_response_to_200
-        self.pager_sync: str = (
-            yaml_data.get("pagerSync")
-            or f"{self.code_model.core_library}.paging.ItemPaged"
-        )
-        self.pager_async: str = (
-            yaml_data.get("pagerAsync")
-            or f"{self.code_model.core_library}.paging.AsyncItemPaged"
-        )
+        self.pager_sync: str = yaml_data.get("pagerSync") or f"{self.code_model.core_library}.paging.ItemPaged"
+        self.pager_async: str = yaml_data.get("pagerAsync") or f"{self.code_model.core_library}.paging.AsyncItemPaged"
 
     def _get_attr_name(self, wire_name: str) -> str:
         response_type = self.responses[0].type
         if not response_type:
-            raise ValueError(
-                f"Can't find a matching property in response for {wire_name}"
-            )
+            raise ValueError(f"Can't find a matching property in response for {wire_name}")
         if response_type.type == "list":
             response_type = cast(ListType, response_type).element_type
         try:
-            return next(
-                p.client_name
-                for p in cast(ModelType, response_type).properties
-                if p.wire_name == wire_name
-            )
+            return next(p.client_name for p in cast(ModelType, response_type).properties if p.wire_name == wire_name)
         except StopIteration as exc:
-            raise ValueError(
-                f"Can't find a matching property in response for {wire_name}"
-            ) from exc
+            raise ValueError(f"Can't find a matching property in response for {wire_name}") from exc
 
     def get_pager(self, async_mode: bool) -> str:
         return self.responses[0].get_pager(async_mode)
@@ -115,9 +97,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         try:
             item_type_yaml = self.yaml_data["itemType"]
         except KeyError as e:
-            raise ValueError(
-                "Only call this for DPG paging model deserialization"
-            ) from e
+            raise ValueError("Only call this for DPG paging model deserialization") from e
         return cast(ModelType, self.code_model.types_map[id(item_type_yaml)])
 
     @property
@@ -130,13 +110,9 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = super()._imports_shared(async_mode, **kwargs)
         if async_mode:
-            file_import.add_submodule_import(
-                "typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL
-            )
+            file_import.add_submodule_import("typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         else:
-            file_import.add_submodule_import(
-                "typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL
-            )
+            file_import.add_submodule_import("typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if (
             self.next_request_builder
             and self.code_model.options["builders_visibility"] == "embedded"
@@ -161,9 +137,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 ImportType.SDKCORE,
             )
         if self.next_request_builder:
-            file_import.merge(
-                self.get_request_builder_import(self.next_request_builder, async_mode)
-            )
+            file_import.merge(self.get_request_builder_import(self.next_request_builder, async_mode))
         elif any(p.is_api_version for p in self.client.parameters):
             file_import.add_import("urllib.parse", ImportType.STDLIB)
             file_import.add_submodule_import(
@@ -174,12 +148,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         if self.code_model.options["models_mode"] == "dpg":
             relative_path = "..." if async_mode else ".."
             file_import.merge(self.item_type.imports(**kwargs))
-            if self.default_error_deserialization or any(
-                r.type for r in self.responses
-            ):
-                file_import.add_submodule_import(
-                    f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL
-                )
+            if self.default_error_deserialization or any(r.type for r in self.responses):
+                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
         return file_import
 
 

package/autorest/codegen/models/parameter.py

@@ -51,9 +51,7 @@ class ParameterDelimeter(str, Enum):
     COMMA = "comma"
 
 
-class _ParameterBase(
-    BaseModel, abc.ABC
-):  # pylint: disable=too-many-instance-attributes
+class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-attributes
     """Base class for all parameters"""
 
     def __init__(
@@ -66,6 +64,7 @@ class _ParameterBase(
         self.wire_name: str = yaml_data.get("wireName", "")
         self.client_name: str = self.yaml_data["clientName"]
         self.optional: bool = self.yaml_data["optional"]
+        self.implementation: str = yaml_data.get("implementation", None)
         self.location: ParameterLocation = self.yaml_data["location"]
         self.client_default_value = self.yaml_data.get("clientDefaultValue", None)
         self.in_docstring = self.yaml_data.get("inDocstring", True)
@@ -76,9 +75,7 @@ class _ParameterBase(
         self.grouped_by: Optional[str] = self.yaml_data.get("groupedBy")
         # property matching property name to parameter name for grouping params
         # and flattened body params
-        self.property_to_parameter_name: Optional[Dict[str, str]] = self.yaml_data.get(
-            "propertyToParameterName"
-        )
+        self.property_to_parameter_name: Optional[Dict[str, str]] = self.yaml_data.get("propertyToParameterName")
         self.flattened: bool = self.yaml_data.get("flattened", False)
         self.in_flattened_body: bool = self.yaml_data.get("inFlattenedBody", False)
         self.grouper: bool = self.yaml_data.get("grouper", False)
@@ -86,9 +83,7 @@ class _ParameterBase(
         self.added_on: Optional[str] = self.yaml_data.get("addedOn")
         self.is_api_version: bool = self.yaml_data.get("isApiVersion", False)
         self.in_overload: bool = self.yaml_data.get("inOverload", False)
-        self.default_to_unset_sentinel: bool = self.yaml_data.get(
-            "defaultToUnsetSentinel", False
-        )
+        self.default_to_unset_sentinel: bool = self.yaml_data.get("defaultToUnsetSentinel", False)
         self.hide_in_method: bool = self.yaml_data.get("hideInMethod", False)
 
     def get_declaration(self, value: Any = None) -> Any:
@@ -104,9 +99,7 @@ class _ParameterBase(
         Checking to see if it's required, because if not, we don't consider it
         a constant because it can have a value of None.
         """
-        return (not self.optional or self.is_api_version) and isinstance(
-            self.type, ConstantType
-        )
+        return (not self.optional or self.is_api_version) and isinstance(self.type, ConstantType)
 
     @property
     def description(self) -> str:
@@ -170,7 +163,7 @@ class _ParameterBase(
         file_import = FileImport(self.code_model)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
-        if self.added_on:
+        if self.added_on and self.implementation != "Client":
             file_import.add_submodule_import(
                 f"{'.' if async_mode else ''}.._validation",
                 "api_version_validation",
@@ -200,9 +193,7 @@ class _ParameterBase(
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = self._imports_shared(async_mode, **kwargs)
-        file_import.merge(
-            self.type.imports_for_multiapi(async_mode=async_mode, **kwargs)
-        )
+        file_import.merge(self.type.imports_for_multiapi(async_mode=async_mode, **kwargs))
         return file_import
 
     @property
@@ -211,19 +202,11 @@ class _ParameterBase(
 
     @property
     def description_keyword(self) -> str:
-        return (
-            "param"
-            if self.method_location == ParameterMethodLocation.POSITIONAL
-            else "keyword"
-        )
+        return "param" if self.method_location == ParameterMethodLocation.POSITIONAL else "keyword"
 
     @property
     def docstring_type_keyword(self) -> str:
-        return (
-            "type"
-            if self.method_location == ParameterMethodLocation.POSITIONAL
-            else "paramtype"
-        )
+        return "type" if self.method_location == ParameterMethodLocation.POSITIONAL else "paramtype"
 
     @property
     @abc.abstractmethod
@@ -243,10 +226,7 @@ class BodyParameter(_ParameterBase):
 
     @property
     def entries(self) -> List["BodyParameter"]:
-        return [
-            BodyParameter.from_yaml(e, self.code_model)
-            for e in self.yaml_data.get("entries", [])
-        ]
+        return [BodyParameter.from_yaml(e, self.code_model) for e in self.yaml_data.get("entries", [])]
 
     @property
     def is_form_data(self) -> bool:
@@ -261,11 +241,7 @@ class BodyParameter(_ParameterBase):
 
     @property
     def method_location(self) -> ParameterMethodLocation:
-        return (
-            ParameterMethodLocation.KWARG
-            if self.constant
-            else ParameterMethodLocation.POSITIONAL
-        )
+        return ParameterMethodLocation.KWARG if self.constant else ParameterMethodLocation.POSITIONAL
 
     @property
     def in_method_signature(self) -> bool:
@@ -302,9 +278,7 @@ class BodyParameter(_ParameterBase):
         return file_import
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "BodyParameter":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BodyParameter":
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
@@ -312,9 +286,7 @@ class BodyParameter(_ParameterBase):
         )
 
 
-EntryBodyParameterType = TypeVar(
-    "EntryBodyParameterType", bound=Union[BodyParameter, "RequestBuilderBodyParameter"]
-)
+EntryBodyParameterType = TypeVar("EntryBodyParameterType", bound=Union[BodyParameter, "RequestBuilderBodyParameter"])
 
 
 class Parameter(_ParameterBase):
@@ -328,7 +300,6 @@ class Parameter(_ParameterBase):
     ) -> None:
         super().__init__(yaml_data, code_model, type=type)
 
-        self.implementation: str = yaml_data["implementation"]
         self.skip_url_encoding: bool = self.yaml_data.get("skipUrlEncoding", False)
         self.explode: bool = self.yaml_data.get("explode", False)
         self.in_overriden: bool = self.yaml_data.get("inOverriden", False)
@@ -337,10 +308,7 @@ class Parameter(_ParameterBase):
 
     @property
     def hide_in_operation_signature(self) -> bool:
-        if (
-            self.code_model.options["version_tolerant"]
-            and self.client_name == "maxpagesize"
-        ):
+        if self.code_model.options["version_tolerant"] and self.client_name == "maxpagesize":
             return True
         return False
 
@@ -382,10 +350,7 @@ class Parameter(_ParameterBase):
             ParameterLocation.HEADER,
             ParameterLocation.QUERY,
         )
-        if (
-            self.code_model.options["only_path_and_body_params_positional"]
-            and query_or_header
-        ):
+        if self.code_model.options["only_path_and_body_params_positional"] and query_or_header:
             return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL
 
@@ -411,10 +376,7 @@ class ClientParameter(Parameter):
             return ParameterMethodLocation.KWARG
         if (
             self.is_host
-            and (
-                self.code_model.options["version_tolerant"]
-                or self.code_model.options["low_level_client"]
-            )
+            and (self.code_model.options["version_tolerant"] or self.code_model.options["low_level_client"])
             and not self.code_model.options["azure_arm"]
         ):
             # this means i am the base url