Ruff E712: don't compare with True or False

Author: evertlammerts

scripts/generate_connection_methods.py

@@ -14,7 +14,7 @@
 
 
 def is_py_kwargs(method):
-    return "kwargs_as_dict" in method and method["kwargs_as_dict"] == True
+    return "kwargs_as_dict" in method and method["kwargs_as_dict"]
 
 
 def is_py_args(method):

scripts/generate_connection_wrapper_methods.py

@@ -67,7 +67,7 @@ def is_py_args(method):
 
 
 def is_py_kwargs(method):
-    return "kwargs_as_dict" in method and method["kwargs_as_dict"] == True
+    return "kwargs_as_dict" in method and method["kwargs_as_dict"]
 
 
 def remove_section(content, start_marker, end_marker) -> tuple[list[str], list[str]]:

tests/conftest.py

@@ -109,7 +109,7 @@ def pandas_supports_arrow_backend():
     try:
         from pandas.compat import pa_version_under11p0
 
-        if pa_version_under11p0 == True:
+        if pa_version_under11p0:
             return False
     except ImportError:
         return False

tests/fast/api/test_config.py

@@ -44,7 +44,7 @@ def test_external_access(self, duckdb_cursor, pandas):
             con.execute("select * from df").fetchall()
         except Exception:
             query_failed = True
-        assert query_failed == True
+        assert query_failed
 
     def test_extension_setting(self):
         repository = os.environ.get("LOCAL_EXTENSION_REPO")
@@ -59,15 +59,15 @@ def test_unrecognized_option(self, duckdb_cursor):
             duckdb.connect(":memory:", config={"thisoptionisprobablynotthere": "42"})
         except Exception:
             success = False
-        assert success == False
+        assert not success
 
     def test_incorrect_parameter(self, duckdb_cursor):
         success = True
         try:
             duckdb.connect(":memory:", config={"default_null_order": "42"})
         except Exception:
             success = False
-        assert success == False
+        assert not success
 
     def test_user_agent_default(self, duckdb_cursor):
         con_regular = duckdb.connect(":memory:")

tests/fast/api/test_dbapi10.py

@@ -42,8 +42,8 @@ def test_description_comparisons(self):
         assert types[1] == STRING
         assert STRING == types[1]  # noqa: SIM300
         assert types[0] != STRING
-        assert (types[1] != STRING) == False
-        assert (STRING != types[1]) == False  # noqa: SIM300
+        assert not (types[1] != STRING)
+        assert not (STRING != types[1])  # noqa: SIM300
 
         assert types[1] in [STRING]
         assert types[1] in [STRING, NUMBER]

tests/fast/arrow/test_arrow_run_end_encoding.py

@@ -218,7 +218,7 @@ def test_arrow_ree_projections(self, duckdb_cursor, projection):
 
         # Verify that the array is run end encoded
         ar_type = arrow_tbl["ree"].type
-        assert pa.types.is_run_end_encoded(ar_type) == True
+        assert pa.types.is_run_end_encoded(ar_type)
 
         # Scan the arrow table, making projections that don't cover the entire table
         # This should be pushed down into arrow to only provide us with the necessary columns

tests/fast/arrow/test_polars.py

@@ -273,7 +273,7 @@ def test_polars_lazy_pushdown_bool(self, duckdb_cursor):
 
         lazy_df = duck_tbl.pl(lazy=True)
         # == True
-        assert lazy_df.filter(pl.col("a") == True).select(pl.len()).collect().item() == 2
+        assert lazy_df.filter(pl.col("a")).select(pl.len()).collect().item() == 2
 
         # IS NULL
         assert lazy_df.filter(pl.col("a").is_null()).select(pl.len()).collect().item() == 1
@@ -282,17 +282,17 @@ def test_polars_lazy_pushdown_bool(self, duckdb_cursor):
         assert lazy_df.filter(pl.col("a").is_not_null()).select(pl.len()).collect().item() == 3
 
         # AND
-        assert lazy_df.filter((pl.col("a") == True) & (pl.col("b") == True)).select(pl.len()).collect().item() == 1
+        assert lazy_df.filter((pl.col("a")) & (pl.col("b"))).select(pl.len()).collect().item() == 1
 
         # OR
-        assert lazy_df.filter((pl.col("a") == True) | (pl.col("b") == True)).select(pl.len()).collect().item() == 3
+        assert lazy_df.filter((pl.col("a")) | (pl.col("b"))).select(pl.len()).collect().item() == 3
 
         # Validate Filters
-        valid_filter(pl.col("a") == True)
+        valid_filter(pl.col("a"))
         valid_filter(pl.col("a").is_null())
         valid_filter(pl.col("a").is_not_null())
-        valid_filter((pl.col("a") == True) & (pl.col("b") == True))
-        valid_filter((pl.col("a") == True) | (pl.col("b") == True))
+        valid_filter((pl.col("a")) & (pl.col("b")))
+        valid_filter((pl.col("a")) | (pl.col("b")))
 
     def test_polars_lazy_pushdown_time(self, duckdb_cursor):
         duckdb_cursor.execute(

tests/fast/pandas/test_copy_on_write.py

@@ -35,7 +35,7 @@ class TestCopyOnWrite:
         ],
     )
     def test_copy_on_write(self, col):
-        assert pandas.options.mode.copy_on_write == True
+        assert pandas.options.mode.copy_on_write
         con = duckdb.connect()
         df_in = pandas.DataFrame(  # noqa: F841
             {

tests/fast/pandas/test_df_object_resolution.py

@@ -511,18 +511,18 @@ def test_ubigint_object_conversion(self, pandas, duckdb_cursor):
         converted_col = duckdb_cursor.sql("select * from x").df()
         if pandas.backend == "numpy_nullable":
             float64 = np.dtype("float64")
-            assert isinstance(converted_col["0"].dtype, float64.__class__) == True
+            assert isinstance(converted_col["0"].dtype, float64.__class__)
         else:
             uint64 = np.dtype("uint64")
-            assert isinstance(converted_col["0"].dtype, uint64.__class__) == True
+            assert isinstance(converted_col["0"].dtype, uint64.__class__)
 
     @pytest.mark.parametrize("pandas", [NumpyPandas()])
     def test_double_object_conversion(self, pandas, duckdb_cursor):
         data = [18446744073709551616, 0]
         x = pandas.DataFrame({"0": pandas.Series(data=data, dtype="object")})
         converted_col = duckdb_cursor.sql("select * from x").df()
         double_dtype = np.dtype("float64")
-        assert isinstance(converted_col["0"].dtype, double_dtype.__class__) == True
+        assert isinstance(converted_col["0"].dtype, double_dtype.__class__)
 
     @pytest.mark.parametrize("pandas", [NumpyPandas(), ArrowPandas()])
     @pytest.mark.xfail(
@@ -569,7 +569,7 @@ def test_integer_conversion_fail(self, pandas, duckdb_cursor):
         converted_col = duckdb_cursor.sql("select * from x").df()
         print(converted_col["0"])
         double_dtype = np.dtype("object")
-        assert isinstance(converted_col["0"].dtype, double_dtype.__class__) == True
+        assert isinstance(converted_col["0"].dtype, double_dtype.__class__)
 
     # Most of the time numpy.datetime64 is just a wrapper around a datetime.datetime object
     # But to support arbitrary precision, it can fall back to using an `int` internally

tests/fast/pandas/test_timedelta.py

@@ -79,8 +79,8 @@ def create_python_interval(
         equality = "select {value} = $1, {value}, $1"
         equality = equality.format(value=duck_interval)
         res, a, b = duckdb_cursor.execute(equality, [val]).fetchone()
-        if res != True:
+        if not res:
             # TODO: in some cases intervals that are identical don't compare equal.  # noqa: TD002, TD003
             assert a == b
         else:
-            assert res == True
+            assert res