[BE][Easy] fix ruff rule needless-bool (SIM103) (pytorch#130206)

XuehaiPan · pytorchmergebot · commit 4d7bf72d9379 · 2024-07-14T08:17:52.000Z
Pull Request resolved: pytorch#130206 Approved by: https://github.com/malfet
diff --git a/benchmarks/dynamo/training_loss.py b/benchmarks/dynamo/training_loss.py
@@ -99,10 +99,7 @@ def check_loss(ref_loss, res_loss):
     assert len(ref_loss) == len(res_loss)
     length = len(ref_loss)
     x = min(length, 10)
-    if sum(res_loss[-x:]) / 10 <= sum(ref_loss[-x:]) / 10 + 1e-1:
-        return True
-    else:
-        return False
+    return sum(res_loss[-x:]) / 10 <= sum(ref_loss[-x:]) / 10 + 0.1
 
 
 def parse_args():
diff --git a/benchmarks/operator_benchmark/benchmark_core.py b/benchmarks/operator_benchmark/benchmark_core.py
@@ -339,16 +339,12 @@ def _check_keep(self, test_flag, cmd_flag):
         return cmd_flag is None or test_flag == cmd_flag
 
     def _check_operator_first_char(self, test_flag, cmd_flag):
-        if cmd_flag is None or test_flag[:1].lower() in cmd_flag:
-            return True
-        return False
+        return cmd_flag is None or test_flag[:1].lower() in cmd_flag
 
     def _check_keep_list(self, test_flag, cmd_flag_list):
-        if cmd_flag_list is None or any(
+        return cmd_flag_list is None or any(
             test_flag == cmd_flag for cmd_flag in cmd_flag_list
-        ):
-            return True
-        return False
+        )
 
     def _keep_test(self, test_case):
         # TODO: consider regex matching for test filtering.
@@ -362,7 +358,7 @@ def _keep_test(self, test_case):
         )
 
         # Filter framework, operator, test_name, tag, forward_only
-        if (
+        return (
             self._check_keep(op_test_config.test_name, self.args.test_name)
             and self._check_keep_list(test_case.op_bench.module_name(), operators)
             and self._check_operator_first_char(
@@ -381,10 +377,7 @@ def _keep_test(self, test_case):
                 or "device" not in test_case.test_config.input_config
                 or self.args.device in op_test_config.test_name
             )
-        ):
-            return True
-
-        return False
+        )
 
     def _print_test_case_info(self, test_case):
         # Print out the test name and skip the real execution
diff --git a/scripts/compile_tests/common.py b/scripts/compile_tests/common.py
@@ -43,10 +43,7 @@ def find(testcase, condition):
 
 def skipped_test(testcase):
     def condition(children):
-        tags = [child.tag for child in children]
-        if "skipped" in tags:
-            return True
-        return False
+        return "skipped" in {child.tag for child in children}
 
     return find(testcase, condition)
 
@@ -55,12 +52,8 @@ def passed_test(testcase):
     def condition(children):
         if len(children) == 0:
             return True
-        tags = [child.tag for child in children]
-        if "skipped" in tags:
-            return False
-        if "failed" in tags:
-            return False
-        return True
+        tags = {child.tag for child in children}
+        return "skipped" not in tags and "failed" not in tags
 
     return find(testcase, condition)
 
diff --git a/scripts/compile_tests/passrate.py b/scripts/compile_tests/passrate.py
@@ -41,13 +41,7 @@ def should_exclude(key):
     if test_file == "UNKNOWN":
         return True
     # Policy: "pass rate" does not include inductor, export, or dynamo tests.
-    if test_file.startswith("inductor/"):
-        return True
-    if test_file.startswith("export/"):
-        return True
-    if test_file.startswith("dynamo/"):
-        return True
-    return False
+    return test_file.startswith(("inductor/", "export/", "dynamo/"))
 
 
 def compute_pass_rate(eager_dir, dynamo_dir):
diff --git a/test/dynamo/test_higher_order_ops.py b/test/dynamo/test_higher_order_ops.py
@@ -39,9 +39,7 @@
 
 def check_dynamic_shape_capture():
     # This also mirrors config from `test/dynamo/test_dynamic_shapes.py:make_dynamic_cls`
-    if not config.assume_static_by_default:
-        return True
-    return False
+    return not config.assume_static_by_default
 
 
 def count_ops(gm, args, freq, op):
diff --git a/test/dynamo/test_structured_trace.py b/test/dynamo/test_structured_trace.py
@@ -56,9 +56,7 @@ def inductor_schedule_fn(a):
 
 class StructuredTraceTestingFilter(logging.Filter):
     def filter(self, record):
-        if "str" in record.metadata:
-            return False
-        return True
+        return "str" not in record.metadata
 
 
 class StructuredTraceTestingFormatter(logging.Formatter):
diff --git a/test/fx/test_subgraph_rewriter.py b/test/fx/test_subgraph_rewriter.py
@@ -844,9 +844,7 @@ def second_input_is_scalar(match, original_graph, pattern_graph):
                     if input_idx == 1:
                         num_node = node
                     input_idx += 1
-            if not isinstance(match.nodes_map[num_node], (int, float)):
-                return False
-            return True
+            return isinstance(match.nodes_map[num_node], (int, float))
 
         def check_replacement_nodes(self, traced, matches):
             replacement_nodes_in_graph = [
diff --git a/test/jit/test_data_parallel.py b/test/jit/test_data_parallel.py
@@ -114,11 +114,10 @@ def test_tensor_sharing(self):
 
         def assert_share_data(t1, t2):
             # Only checks that they point to the same memory on the same device.
-            if t1.device != t2.device:
-                return False
-            if t1.storage().data_ptr() != t2.storage().data_ptr():
-                return False
-            return True
+            return (
+                t1.device == t2.device
+                and t1.storage().data_ptr() == t2.storage().data_ptr()
+            )
 
         for p1, p2 in zip(module.parameters(), replica[0].parameters()):
             self.assertTrue(assert_share_data(p1, p2))
diff --git a/test/run_test.py b/test/run_test.py
@@ -104,9 +104,7 @@ def maybe_set_hip_visible_devies():
 
 
 def strtobool(s):
-    if s.lower() in ["", "0", "false", "off"]:
-        return False
-    return True
+    return s.lower() not in {"", "0", "false", "off"}
 
 
 class TestChoices(list):
diff --git a/test/test_jit.py b/test/test_jit.py
@@ -167,7 +167,7 @@ def doAutodiffCheck(testname):
     # these tests are disabled because BailOut nodes
     # inserted by ProfilingExecutor interfere with
     # subgraph slicing of Differentiable Graphs
-    test_exceptions = [
+    test_exceptions = (
         # functional
         'test_nn_dropout',
         'test_nn_log_softmax',
@@ -195,11 +195,9 @@ def doAutodiffCheck(testname):
         'test_split_with_sizes_dim_neg0',
         'test_split_with_sizes_size_0',
         'test_nn_max_pool2d_with_indices',
-    ]
+    )
 
-    if testname in test_exceptions:
-        return False
-    return True
+    return testname not in test_exceptions
 
 
 # TODO: enable TE in PE when all tests are fixed
diff --git a/test/test_modules.py b/test/test_modules.py
@@ -365,9 +365,7 @@ def _can_be_noncontiguous(obj):
             elif isinstance(obj, dict):
                 return any(_can_be_noncontiguous(o) for o in obj.values())
             # scalar tensors can not be non-contiguous
-            if not isinstance(obj, torch.Tensor) or obj.dim() == 0:
-                return False
-            return True
+            return isinstance(obj, torch.Tensor) and obj.dim() != 0
 
         for module_input in module_inputs:
             if module_input.forward_input is None:
diff --git a/test/test_ops.py b/test/test_ops.py
@@ -113,11 +113,7 @@ def reduction_dtype_filter(op):
         or torch.int16 not in op.dtypes
     ):
         return False
-
-    argspec = inspect.getfullargspec(op.op)
-    if "dtype" not in argspec.kwonlyargs:
-        return False
-    return True
+    return "dtype" in inspect.getfullargspec(op.op).kwonlyargs
 
 
 # Create a list of operators that are a subset of _ref_test_ops but don't have a
diff --git a/test/test_overrides.py b/test/test_overrides.py
@@ -149,13 +149,7 @@ def __torch_function__(cls, func, types, args=(), kwargs=None):
         return cls.handled_functions[func](*args, **kwargs)
 
     def __eq__(self, other):
-        if type(other) is type(self):
-            if self._N == other._N and self._i == other._i:
-                return True
-            else:
-                return False
-        else:
-            return False
+        return type(other) is type(self) and self._N == other._N and self._i == other._i
 
 @implements_diagonal(torch.mean)
 def mean(mat):
diff --git a/tools/autograd/load_derivatives.py b/tools/autograd/load_derivatives.py
@@ -436,10 +436,7 @@ def is_forward_derivative_definition(
     all_arg_names: list[str], names: tuple[str, ...]
 ) -> bool:
     for name in names:
-        if name not in all_arg_names:
-            return True
-        else:
-            return False
+        return name not in all_arg_names
     raise RuntimeError("Expected `names` to be non-empty")
 
 
diff --git a/tools/code_coverage/package/tool/parser/gcov_coverage_parser.py b/tools/code_coverage/package/tool/parser/gcov_coverage_parser.py
@@ -22,9 +22,7 @@ def _skip_coverage(path: str) -> bool:
         This is repo-specific and only makes sense for the current state of
         ovrsource.
         """
-        if "third-party" in path:
-            return True
-        return False
+        return "third-party" in path
 
     def parse(self) -> list[CoverageRecord]:
         # The JSON format is described in the gcov source code
diff --git a/tools/code_coverage/package/tool/parser/llvm_coverage_parser.py b/tools/code_coverage/package/tool/parser/llvm_coverage_parser.py
@@ -24,9 +24,7 @@ def _skip_coverage(path: str) -> bool:
         This is repo-specific and only makes sense for the current state of
         ovrsource.
         """
-        if "/third-party/" in path:
-            return True
-        return False
+        return "/third-party/" in path
 
     @staticmethod
     def _collect_coverage(
diff --git a/torch/_dynamo/repro/after_dynamo.py b/torch/_dynamo/repro/after_dynamo.py
@@ -361,12 +361,11 @@ def backend_fails(gm, example_inputs, compiler_fn, orig_failure):
         run_fwd_maybe_bwd(gm, clone_inputs_retaining_gradness(example_inputs))
         compiled_gm = compiler_fn(gm, example_inputs)
         run_fwd_maybe_bwd(compiled_gm, clone_inputs_retaining_gradness(example_inputs))
-        return False
     except Exception as e:
         new_failure = str(e)
         if SequenceMatcher(None, orig_failure, new_failure).ratio() > 0.5:
             return True
-        return False
+    return False
 
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
diff --git a/torch/_dynamo/variables/builder.py b/torch/_dynamo/variables/builder.py
@@ -341,14 +341,12 @@ def __call__(self, value):
         return vt
 
     def _can_lift_attrs_to_inputs(self, vt):
-        if type(vt) in [
+        return type(vt) in {
             TensorVariable,
             TensorWithTFOverrideVariable,
             UserDefinedObjectVariable,
             NumpyNdarrayVariable,
-        ]:
-            return True
-        return False
+        }
 
     @staticmethod
     @functools.lru_cache(None)
diff --git a/torch/_functorch/_aot_autograd/input_output_analysis.py b/torch/_functorch/_aot_autograd/input_output_analysis.py
@@ -338,8 +338,6 @@ def _tensors_definitely_do_not_overlap(x, y):
             # without
             if offset_delta_mod + y.size(1) <= x.stride(0):
                 return True
-            else:
-                return False
     return False
 
 
diff --git a/torch/_inductor/codegen/wrapper.py b/torch/_inductor/codegen/wrapper.py
@@ -1824,17 +1824,14 @@ def codegen_free(self, buffer):
 
     def can_reuse(self, input_buffer, output_buffer=None):
         name = input_buffer.get_name()
-        if (
+        return not (
             name in V.graph.removed_buffers
             or name in V.graph.graph_inputs
             or name in V.graph.constants
             or name in V.graph.torchbind_constants
             or name in V.graph.never_reuse_buffers
             or name in self.freed
-        ):
-            return False
-
-        return True
+        )
 
     def did_reuse(self, buffer, reused_buffer):
         # Check whether a given buffer was reused by a possible reuser in the wrapper codegen
diff --git a/torch/_inductor/fx_passes/group_batch_fusion.py b/torch/_inductor/fx_passes/group_batch_fusion.py
@@ -562,11 +562,7 @@ def fuse(self, graph: torch.fx.GraphModule, subset: List[torch.fx.Node]):
 
 
 def is_node_meta_valid(node: Optional[torch.fx.Node]):
-    if node is None:
-        return True
-    if "example_value" not in node.meta and "val" not in node.meta:
-        return False
-    return True
+    return node is None or "example_value" in node.meta or "val" in node.meta
 
 
 # Poor person's check for if a node in the graph mutates its input.
diff --git a/torch/_inductor/fx_passes/quantization.py b/torch/_inductor/fx_passes/quantization.py
@@ -607,13 +607,7 @@ def fn(match):
             )
         )
         if (
-            len(
-                _get_remaining_users(
-                    extra_input_of_pattern,
-                    compute_node,
-                )
-            )
-            > 1
+            len(_get_remaining_users(extra_input_of_pattern, compute_node)) > 1
             or extra_input_of_pattern == compute_node.args[0]
         ):
             return False
diff --git a/torch/_inductor/sizevars.py b/torch/_inductor/sizevars.py
@@ -310,11 +310,9 @@ def statically_known_list_equals(self, left: List[Expr], right: List[Expr]) -> b
         """
         Returns a bool indicating if it is sound to optimize as if left and right lists are equal.
         """
-        if len(left) != len(right):
-            return False
-        if all(self.statically_known_equals(l, r) for l, r in zip(left, right)):
-            return True
-        return False
+        return len(left) == len(right) and all(
+            self.statically_known_equals(l, r) for l, r in zip(left, right)
+        )
 
     # See Note - [On Statically Known]
     def statically_known_leq(self, left: Expr, right: Union[Expr, int]) -> bool:
diff --git a/torch/_prims_common/__init__.py b/torch/_prims_common/__init__.py
@@ -687,13 +687,7 @@ def is_valid_permutation(rank: int, perm: DimsSequenceType) -> bool:
     Validates that perm is a permutation of length rank.
     """
 
-    if not isinstance(perm, Sequence):
-        return False
-
-    if not (tuple(sorted(perm)) == tuple(range(0, rank))):
-        return False
-
-    return True
+    return isinstance(perm, Sequence) and sorted(perm) == list(range(rank))
 
 
 def is_same_shape(a: Sequence, b: Sequence) -> bool:
diff --git a/torch/_refs/__init__.py b/torch/_refs/__init__.py
@@ -354,9 +354,7 @@
 
 
 def is_noncontiguous_supported(device):
-    if device is not None and device.type == "hpu":
-        return False
-    return True
+    return device is None or device.type != "hpu"
 
 
 def handle_noncontiguous_outputs(input_tlist, output):
diff --git a/torch/_subclasses/fake_impls.py b/torch/_subclasses/fake_impls.py
@@ -54,9 +54,7 @@ def ordered_set(*items):
 # This function indicates if the backend device
 # supports non-contiguous tensors
 def is_noncontiguous_supported(device):
-    if device.type == "hpu":
-        return False
-    return True
+    return device.type != "hpu"
 
 
 _like_tensor_constructors = ordered_set(
diff --git a/torch/distributed/_tensor/placement_types.py b/torch/distributed/_tensor/placement_types.py
diff --git a/torch/distributed/fsdp/_state_dict_utils.py b/torch/distributed/fsdp/_state_dict_utils.py
diff --git a/torch/distributed/remote_device.py b/torch/distributed/remote_device.py
diff --git a/torch/fx/passes/infra/pass_manager.py b/torch/fx/passes/infra/pass_manager.py
diff --git a/torch/fx/passes/operator_support.py b/torch/fx/passes/operator_support.py
diff --git a/torch/fx/passes/pass_manager.py b/torch/fx/passes/pass_manager.py
diff --git a/torch/onnx/verification.py b/torch/onnx/verification.py
diff --git a/torch/utils/cpp_extension.py b/torch/utils/cpp_extension.py
diff --git a/torch/utils/data/graph_settings.py b/torch/utils/data/graph_settings.py
