Fix explicit comparison to True/False

Signed-off-by: Fynn Schmitt-Ulms <[email protected]>

Author: fynnsu

tests/test_utils/test_match.py

@@ -70,43 +70,35 @@ class TestMatchName:
 
     def test_exact_match(self):
         """Test exact string matching"""
-        assert _match_name("layer1", "layer1") == True
-        assert _match_name("layer1", "layer2") == False
-        assert (
-            _match_name(
-                "transformer.layers.0.self_attn.q_proj",
-                "transformer.layers.0.self_attn.q_proj",
-            )
-            == True
+        assert _match_name("layer1", "layer1")
+        assert not _match_name("layer1", "layer2")
+        assert _match_name(
+            "transformer.layers.0.self_attn.q_proj",
+            "transformer.layers.0.self_attn.q_proj",
         )
 
     def test_regex_match(self):
         """Test regex matching with "re:" prefix"""
-        assert _match_name("layer1", "re:layer.*") == True
-        assert _match_name("layer1", "re:^layer1$") == True
-        assert _match_name("layer1", "re:layer2") == False
-        assert (
-            _match_name("transformer.layers.0.self_attn.q_proj", "re:.*q_proj") == True
-        )
-        assert (
-            _match_name(
-                "transformer.layers.0.self_attn.q_proj",
-                "re:transformer\\.layers\\.\\d+\\.self_attn\\..*_proj$",
-            )
-            == True
+        assert _match_name("layer1", "re:layer.*")
+        assert _match_name("layer1", "re:^layer1$")
+        assert not _match_name("layer1", "re:layer2")
+        assert _match_name("transformer.layers.0.self_attn.q_proj", "re:.*q_proj")
+        assert _match_name(
+            "transformer.layers.0.self_attn.q_proj",
+            "re:transformer\\.layers\\.\\d+\\.self_attn\\..*_proj$",
         )
 
     def test_empty_strings(self):
         """Test edge cases with empty strings"""
-        assert _match_name("", "") == True
-        assert _match_name("layer1", "") == False
-        assert _match_name("", "layer1") == False
+        assert _match_name("", "")
+        assert not _match_name("layer1", "")
+        assert not _match_name("", "layer1")
 
     def test_regex_special_characters(self):
         """Test regex with special characters"""
-        assert _match_name("layer.1", "re:layer\\.1") == True
-        assert _match_name("layer.1", "re:layer.1") == True  # . matches any char
-        assert _match_name("layer_1", "re:layer_1") == True
+        assert _match_name("layer.1", "re:layer\\.1")
+        assert _match_name("layer.1", "re:layer.1")  # . matches any char
+        assert _match_name("layer_1", "re:layer_1")
 
 
 class TestMatchClass:
@@ -115,32 +107,32 @@ class TestMatchClass:
     def test_direct_class_match(self):
         """Test matching direct class names"""
         linear = nn.Linear(10, 20)
-        assert _match_class(linear, "Linear") == True
-        assert _match_class(linear, "Conv2d") == False
+        assert _match_class(linear, "Linear")
+        assert not _match_class(linear, "Conv2d")
 
         norm = nn.LayerNorm(10)
-        assert _match_class(norm, "LayerNorm") == True
-        assert _match_class(norm, "BatchNorm1d") == False
+        assert _match_class(norm, "LayerNorm")
+        assert not _match_class(norm, "BatchNorm1d")
 
     def test_parent_class_match(self):
         """Test matching parent class names"""
         linear = nn.Linear(10, 20)
-        assert _match_class(linear, "Module") == True
+        assert _match_class(linear, "Module")
 
         conv = nn.Conv2d(3, 16, 3)
-        assert _match_class(conv, "Module") == True
-        assert _match_class(conv, "_ConvNd") == True
+        assert _match_class(conv, "Module")
+        assert _match_class(conv, "_ConvNd")
 
     def test_non_torch_module(self):
         """Test with non-torch modules"""
         regular_object = object()
-        assert _match_class(regular_object, "object") == False  # not a torch.nn.Module
+        assert not _match_class(regular_object, "object")  # not a torch.nn.Module
 
     def test_custom_module(self):
         """Test with custom module classes"""
         model = DummyModel()
-        assert _match_class(model, "DummyModel") == True
-        assert _match_class(model, "Module") == True
+        assert _match_class(model, "DummyModel")
+        assert _match_class(model, "Module")
 
 
 class TestIsMatch:
@@ -149,27 +141,27 @@ class TestIsMatch:
     def test_name_match(self):
         """Test matching by name"""
         linear = nn.Linear(10, 20)
-        assert is_match("layer1", linear, "layer1") == True
-        assert is_match("layer1", linear, "layer2") == False
+        assert is_match("layer1", linear, "layer1")
+        assert not is_match("layer1", linear, "layer2")
 
     def test_class_match(self):
         """Test matching by class"""
         linear = nn.Linear(10, 20)
-        assert is_match("layer1", linear, "Linear") == True
-        assert is_match("layer1", linear, "Conv2d") == False
+        assert is_match("layer1", linear, "Linear")
+        assert not is_match("layer1", linear, "Conv2d")
 
     def test_combined_match(self):
         """Test that either name or class match works"""
         linear = nn.Linear(10, 20)
-        assert is_match("layer1", linear, "layer1") == True  # name match
-        assert is_match("layer1", linear, "Linear") == True  # class match
-        assert is_match("layer1", linear, "layer2") == False  # no match
+        assert is_match("layer1", linear, "layer1")  # name match
+        assert is_match("layer1", linear, "Linear")  # class match
+        assert not is_match("layer1", linear, "layer2")  # no match
 
     def test_regex_in_name_match(self):
         """Test regex matching in name"""
         linear = nn.Linear(10, 20)
-        assert is_match("layer1", linear, "re:layer.*") == True
-        assert is_match("layer1", linear, "re:conv.*") == False
+        assert is_match("layer1", linear, "re:layer.*")
+        assert not is_match("layer1", linear, "re:conv.*")
 
     def test_internal_module_match(self):
         """Test not matching internal modules"""
@@ -178,7 +170,7 @@ class InternalLinear(InternalModule, nn.Linear):
             pass
 
         linear = InternalLinear(10, 20)
-        assert is_match("layer1", linear, "re:layer.*") == False
+        assert not is_match("layer1", linear, "re:layer.*")
 
 
 class TestMatchNamedModules: