[CodeStyle] black -> ruff format migration - part 33 (#74747)

Author: gouzil

.pre-commit-config.yaml

@@ -91,7 +91,7 @@ repos:
 
             | python/paddle/[k-n].+
 
-            # | python/paddle/[o-t].+
+            | python/paddle/[o-t].+
 
             | python/paddle/[u-z].+
 
@@ -147,7 +147,7 @@ repos:
 
             # | python/paddle/[k-n].+
 
-            | python/paddle/[o-t].+
+            # | python/paddle/[o-t].+
 
             # | python/paddle/[u-z].+
 

python/paddle/optimizer/adamw.py

@@ -255,9 +255,9 @@ def __init__(
         if self._parameter_list:
             if isinstance(self._parameter_list[0], dict):
                 for param_group in self._parameter_list:
-                    assert (
-                        'params' in param_group
-                    ), 'params should be set in parameters if parameter groups are optimized in different options'
+                    assert 'params' in param_group, (
+                        'params should be set in parameters if parameter groups are optimized in different options'
+                    )
                 self._dtype = self._parameter_list[0]['params'][0].dtype
             else:
                 self._dtype = self._parameter_list[0].dtype

python/paddle/optimizer/fusion_utils.py

@@ -52,9 +52,9 @@ def get_current_device_type():
                 device_type = current_device.get_device_type()
             except:
                 device_type = "unknown"
-        assert (
-            device_type in alignment.keys()
-        ), f"tensor fusion helper now only support {alignment.keys()}, but got device {device_type} instead."
+        assert device_type in alignment.keys(), (
+            f"tensor fusion helper now only support {alignment.keys()}, but got device {device_type} instead."
+        )
         __current_device_type__ = device_type
     return __current_device_type__
 
@@ -210,13 +210,13 @@ def reset_meta(
         merged_model_params_meta,
         buffer_ipc_meta,
     ):
-        assert isinstance(
-            accumulators_meta, dict
-        ), "accumulators_meta must be a dict"
+        assert isinstance(accumulators_meta, dict), (
+            "accumulators_meta must be a dict"
+        )
         self.accumulators_meta = accumulators_meta
-        assert isinstance(
-            master_weights_meta, dict
-        ), "master_weights_meta must be a dict"
+        assert isinstance(master_weights_meta, dict), (
+            "master_weights_meta must be a dict"
+        )
         self.master_weights_meta = master_weights_meta
         assert (
             isinstance(merged_model_params_meta, dict)
@@ -242,9 +242,9 @@ def sync_partial_param(self, start, end):
         assert isinstance(start, int), "start must be an integer"
         assert isinstance(end, int), "end must be an integer"
         assert start >= 0, "start must be non-negative"
-        assert (
-            end <= self.buffer_length
-        ), "end must be less than or equal to the total buffer length"
+        assert end <= self.buffer_length, (
+            "end must be less than or equal to the total buffer length"
+        )
         task = async_offload_with_offset(
             src_tensor=self.buffer,
             dst_tensor=self.cpu_buffer,

python/paddle/optimizer/lr.py

@@ -238,9 +238,9 @@ def state_dict(self) -> _LRStateDict:
                 continue
             value = self.__dict__[key]
             if isinstance(value, Tensor):
-                assert (
-                    value.size == 1
-                ), "numel of Tensor in state_dict must be 1"
+                assert value.size == 1, (
+                    "numel of Tensor in state_dict must be 1"
+                )
                 value = float(value)
             state_dict[key] = value
 
@@ -598,9 +598,9 @@ def __init__(
         last_epoch: int = -1,
         verbose: bool = False,
     ) -> None:
-        assert (
-            gamma > 0.0
-        ), " 'gamma' must be a positive number so that the learning rate will decay."
+        assert gamma > 0.0, (
+            " 'gamma' must be a positive number so that the learning rate will decay."
+        )
         self.gamma = gamma
         super().__init__(learning_rate, last_epoch, verbose)
 
@@ -812,14 +812,14 @@ def __init__(
         last_epoch: int = -1,
         verbose: bool = False,
     ):
-        assert decay_steps > 0 and isinstance(
-            decay_steps, int
-        ), " 'decay_steps' must be a positive integer."
+        assert decay_steps > 0 and isinstance(decay_steps, int), (
+            " 'decay_steps' must be a positive integer."
+        )
         self.decay_steps = decay_steps
         self.end_lr = end_lr
-        assert (
-            power > 0.0
-        ), " 'power' must be greater than 0.0 so that the learning rate will decay."
+        assert power > 0.0, (
+            " 'power' must be greater than 0.0 so that the learning rate will decay."
+        )
         self.power = power
         self.cycle = cycle
         super().__init__(learning_rate, last_epoch, verbose)
@@ -955,15 +955,15 @@ def __init__(
                 f"the type of learning_rate should be [int, float or LRScheduler], the current type is {learning_rate}"
             )
         self.learning_rate = learning_rate
-        assert warmup_steps > 0 and isinstance(
-            warmup_steps, int
-        ), " 'warmup_steps' must be a positive integer."
+        assert warmup_steps > 0 and isinstance(warmup_steps, int), (
+            " 'warmup_steps' must be a positive integer."
+        )
         self.warmup_steps = warmup_steps
         self.start_lr = start_lr
         self.end_lr = end_lr
-        assert (
-            end_lr > start_lr
-        ), f"end_lr {end_lr} must be greater than start_lr {start_lr}"
+        assert end_lr > start_lr, (
+            f"end_lr {end_lr} must be greater than start_lr {start_lr}"
+        )
         super().__init__(start_lr, last_epoch, verbose)
 
     def state_dict(self) -> _LRStateDict:
@@ -1085,9 +1085,9 @@ def __init__(
         last_epoch: int = -1,
         verbose: bool = False,
     ) -> None:
-        assert (
-            gamma > 0.0 and gamma < 1.0
-        ), " 'gamma' must be in interval (0.0, 1.0) so that the learning rate will decay."
+        assert gamma > 0.0 and gamma < 1.0, (
+            " 'gamma' must be in interval (0.0, 1.0) so that the learning rate will decay."
+        )
         self.gamma = gamma
         super().__init__(learning_rate, last_epoch, verbose)
 
@@ -1321,9 +1321,9 @@ def __init__(
         if gamma >= 1.0:
             raise ValueError('gamma should be < 1.0.')
 
-        assert step_size > 0 and isinstance(
-            step_size, int
-        ), " 'step_size' must be a positive integer."
+        assert step_size > 0 and isinstance(step_size, int), (
+            " 'step_size' must be a positive integer."
+        )
         self.step_size = step_size
         self.gamma = gamma
         super().__init__(learning_rate, last_epoch, verbose)
@@ -1784,9 +1784,9 @@ def __init__(
             raise TypeError(
                 f"The type of 'eta_min' in 'CosineAnnealingDecay' must be 'float, int', but received {type(eta_min)}."
             )
-        assert T_max > 0 and isinstance(
-            T_max, int
-        ), " 'T_max' must be a positive integer."
+        assert T_max > 0 and isinstance(T_max, int), (
+            " 'T_max' must be a positive integer."
+        )
         self.T_max = T_max
         self.eta_min = float(eta_min)
         super().__init__(learning_rate, last_epoch, verbose)

python/paddle/optimizer/momentum.py

@@ -553,9 +553,7 @@ def _append_optimize_multi_tensor_op(
                         "use_nesterov": self._use_nesterov,
                         "regularization_method": self._regularization_method_dict[
                             key
-                        ][
-                            param_group_idx
-                        ],
+                        ][param_group_idx],
                         "regularization_coeff": self._regularization_coeff_dict[
                             key
                         ][param_group_idx],

python/paddle/optimizer/optimizer.py

@@ -94,14 +94,14 @@ def append_backward_new(
     from paddle.incubate.autograd.primx import Transform, orig2prim
 
     program = default_main_program()
-    assert (
-        program.num_blocks == 1
-    ), "The append_backward_new interface is designed to process only one block."
+    assert program.num_blocks == 1, (
+        "The append_backward_new interface is designed to process only one block."
+    )
     block = program.current_block()
     for el in loss_list:
-        assert (
-            el.block == block
-        ), 'variable in loss_list should be in current block of main program'
+        assert el.block == block, (
+            'variable in loss_list should be in current block of main program'
+        )
 
     orig2prim(block)
     ad = Transform(block)
@@ -280,9 +280,9 @@ def __init__(
         if self._parameter_list:
             if isinstance(self._parameter_list[0], dict):
                 for param_group in self._parameter_list:
-                    assert (
-                        'params' in param_group
-                    ), 'params should be set in parameters if parameter groups are optimized in different options'
+                    assert 'params' in param_group, (
+                        'params should be set in parameters if parameter groups are optimized in different options'
+                    )
                 self._dtype = self._parameter_list[0]['params'][0].dtype
             else:
                 self._dtype = self._parameter_list[0].dtype
@@ -477,9 +477,9 @@ def set_state_dict(self, state_dict: dict[str, Tensor]) -> None:
         if isinstance(self._learning_rate, LRScheduler):
             lr_state_dict = state_dict.get("LR_Scheduler", None)
             if not isinstance(self._learning_rate, LambdaDecay):
-                assert (
-                    lr_state_dict is not None
-                ), "LR_Scheduler state must be included in the state dict except LambdaDecay"
+                assert lr_state_dict is not None, (
+                    "LR_Scheduler state must be included in the state dict except LambdaDecay"
+                )
             if lr_state_dict:
                 self._learning_rate.set_state_dict(lr_state_dict)
 
@@ -495,9 +495,9 @@ def set_state_dict(self, state_dict: dict[str, Tensor]) -> None:
         self._accumulators_holder = state_dict
         for k, v in self._accumulators.items():
             for para_name, var_tmp in v.items():
-                assert (
-                    var_tmp.name in state_dict
-                ), f"optimizer Tensor {var_tmp.name} not found"
+                assert var_tmp.name in state_dict, (
+                    f"optimizer Tensor {var_tmp.name} not found"
+                )
 
                 var = var_tmp.value()
                 tensor = var.get_tensor()
@@ -1112,9 +1112,9 @@ def _add_accumulator(
 
             if framework.in_dygraph_mode():
                 if len(self._accumulators_holder) > 0:
-                    assert (
-                        var_name in self._accumulators_holder
-                    ), f"Optimizer set error, {var_name} should in state dict"
+                    assert var_name in self._accumulators_holder, (
+                        f"Optimizer set error, {var_name} should in state dict"
+                    )
                     var.set_value(self._accumulators_holder.pop(var_name))
 
                     # load scale value for xpu
@@ -1231,9 +1231,9 @@ def _create_optimization_pass(
         target_block = global_block
         current_block = framework.default_main_program().current_block()
         if current_block.idx != global_block.idx:
-            assert (
-                current_block.backward_block_idx != -1
-            ), "current block is not global_block, but it doesn't have backward block."
+            assert current_block.backward_block_idx != -1, (
+                "current block is not global_block, but it doesn't have backward block."
+            )
             target_block = framework.default_main_program().blocks[
                 current_block.backward_block_idx
             ]
@@ -1669,9 +1669,7 @@ def _apply_optimize(
                 paddle.static.default_main_program(),
                 paddle.static.default_startup_program(),
             ):
-                auto_dp = (
-                    paddle.distributed.auto_parallel.auto_dp_utils.in_auto_dp_mode()
-                )
+                auto_dp = paddle.distributed.auto_parallel.auto_dp_utils.in_auto_dp_mode()
                 if auto_dp:
                     paddle.distributed.auto_parallel.auto_dp_utils._convert_fake_replicate_grad_to_partial(
                         params_grads
@@ -1943,9 +1941,9 @@ def minimize(
                 >>> adam.clear_grad()
 
         """
-        assert isinstance(
-            loss, (Variable, paddle.pir.Value)
-        ), "The loss should be an Tensor."
+        assert isinstance(loss, (Variable, paddle.pir.Value)), (
+            "The loss should be an Tensor."
+        )
 
         parameter_list = parameters if parameters else self._parameter_list
 
@@ -1969,9 +1967,9 @@ def _declarative_step(self):
         params = (
             paddle.static.default_main_program().global_block().all_parameters()
         )
-        assert not isinstance(
-            self._parameter_list[0], dict
-        ), "Only list of parameters is supported while using optimizer in @paddle.jit.static."
+        assert not isinstance(self._parameter_list[0], dict), (
+            "Only list of parameters is supported while using optimizer in @paddle.jit.static."
+        )
         selected_params = {param.name for param in self._parameter_list}
         parameters = [param for param in params if param.trainable]
         parameters = list(
@@ -2141,9 +2139,9 @@ def _is_dtype_fp16_or_bf16(self, dtype):
         :param dtype: instance of core.VarDesc.VarType
         :return: True if dtype is one of fp16 or bf16, False otherwise
         """
-        assert isinstance(
-            dtype, (core.VarDesc.VarType, core.DataType)
-        ), "The dtype should be an instance of core.VarDesc.VarType or core.DataType."
+        assert isinstance(dtype, (core.VarDesc.VarType, core.DataType)), (
+            "The dtype should be an instance of core.VarDesc.VarType or core.DataType."
+        )
         if isinstance(dtype, core.VarDesc.VarType):
             return (
                 dtype == core.VarDesc.VarType.FP16

python/paddle/pir/math_op_patch.py

@@ -1026,9 +1026,9 @@ def indices(self):
         return _C_ops.sparse_indices(self)
 
     def set_shape(self, shape):
-        assert (
-            paddle.base.dygraph.base.in_to_static_mode()
-        ), "We only support call 'set_shape' in to_static mode."
+        assert paddle.base.dygraph.base.in_to_static_mode(), (
+            "We only support call 'set_shape' in to_static mode."
+        )
 
         if self.is_dense_tensor_type() or self.is_selected_row_type():
             type = paddle.pir.create_shaped_type(self.type(), shape)
@@ -1074,9 +1074,9 @@ def _to(
         if blocking is None:
             blocking = True
         else:
-            assert isinstance(
-                blocking, bool
-            ), "blocking value error, must be the True, False or None"
+            assert isinstance(blocking, bool), (
+                "blocking value error, must be the True, False or None"
+            )
 
         def transform(t, device, dtype, blocking):
             if dtype is None:

python/paddle/profiler/utils.py

@@ -128,9 +128,7 @@ def begin(self) -> None:
         if self.event_type not in _AllowedEventTypeList:
             warn(
                 "Only TracerEvent Type in [{}, {}, {}, {}, {}, {},{}]\
-                  can be recorded.".format(
-                    *_AllowedEventTypeList
-                )
+                  can be recorded.".format(*_AllowedEventTypeList)
             )
             self.event = None
         else:

python/paddle/quantization/config.py

@@ -285,7 +285,9 @@ def add_qat_layer_mapping(
         """
         assert isinstance(source, type) and issubclass(
             source, paddle.nn.Layer
-        ), "The source layer to be placed should be a subclass of paddle.nn.Layer"
+        ), (
+            "The source layer to be placed should be a subclass of paddle.nn.Layer"
+        )
         assert isinstance(target, type) and issubclass(
             target, paddle.nn.Layer
         ), "The target layer should be a subclass of paddle.nn.qat.Layer"