Format exchange tests by black

Signed-off-by: Vasily Litvinov <vasilij.n.litvinov@intel.com>

Author: vnlitvinov

pandas/tests/api/conftest.py

@@ -2,15 +2,19 @@
 import pandas as pd
 from pandas.api.exchange.implementation import _from_dataframe
 
-@pytest.fixture(scope='package')
+
+@pytest.fixture(scope="package")
 def df_from_dict():
     def maker(dct, is_categorical=False):
         df = pd.DataFrame(dct)
-        return df.astype('category') if is_categorical else df
+        return df.astype("category") if is_categorical else df
+
     return maker
 
-@pytest.fixture(scope='package')
+
+@pytest.fixture(scope="package")
 def df_from_xchg():
     def maker(xchg):
         return _from_dataframe(xchg)
+
     return maker

pandas/tests/api/test_protocol.py

@@ -2,14 +2,16 @@
 import math
 import ctypes
 
-@pytest.mark.parametrize("test_data",
-                         [
-                             {"a": ["foo", "bar"],
-                              "b": ["baz", "qux"]},
-                             {"a": [1.5, 2.5, 3.5], "b": [9.2, 10.5, 11.8]},
-                             {"A": [1, 2, 3, 4], "B": [1, 2, 3, 4]}
-                         ],
-                         ids=["str_data", "float_data", "int_data"])
+
+@pytest.mark.parametrize(
+    "test_data",
+    [
+        {"a": ["foo", "bar"], "b": ["baz", "qux"]},
+        {"a": [1.5, 2.5, 3.5], "b": [9.2, 10.5, 11.8]},
+        {"A": [1, 2, 3, 4], "B": [1, 2, 3, 4]},
+    ],
+    ids=["str_data", "float_data", "int_data"],
+)
 def test_only_one_dtype(test_data, df_from_dict):
     columns = list(test_data.keys())
     df = df_from_dict(test_data)
@@ -23,10 +25,16 @@ def test_only_one_dtype(test_data, df_from_dict):
 
 
 def test_float_int(df_from_dict):
-    df = df_from_dict({"a": [1, 2, 3], "b": [3, 4, 5],
-                       "c": [1.5, 2.5, 3.5], "d": [9, 10, 11],
-                       "e": [True, False, True],
-                       "f": ["a", "", "c"]})
+    df = df_from_dict(
+        {
+            "a": [1, 2, 3],
+            "b": [3, 4, 5],
+            "c": [1.5, 2.5, 3.5],
+            "d": [9, 10, 11],
+            "e": [True, False, True],
+            "f": ["a", "", "c"],
+        }
+    )
     dfX = df.__dataframe__()
     columns = {"a": 0, "b": 0, "c": 2, "d": 0, "e": 20, "f": 21}
 
@@ -47,15 +55,20 @@ def test_na_float(df_from_dict):
     colX = dfX.get_column_by_name("a")
     assert colX.null_count == 1
 
+
 def test_noncategorical(df_from_dict):
     df = df_from_dict({"a": [1, 2, 3]})
     dfX = df.__dataframe__()
     colX = dfX.get_column_by_name("a")
     with pytest.raises(TypeError):
         colX.describe_categorical
 
+
 def test_categorical(df_from_dict):
-    df = df_from_dict({"weekday": ["Mon", "Tue", "Mon", "Wed", "Mon", "Thu", "Fri", "Sat", "Sun"]}, is_categorical=True)
+    df = df_from_dict(
+        {"weekday": ["Mon", "Tue", "Mon", "Wed", "Mon", "Thu", "Fri", "Sat", "Sun"]},
+        is_categorical=True,
+    )
 
     colX = df.__dataframe__().get_column_by_name("weekday")
     is_ordered, is_dictionary, _ = colX.describe_categorical
@@ -64,14 +77,20 @@ def test_categorical(df_from_dict):
 
 
 def test_dataframe(df_from_dict):
-    df = df_from_dict({"x": [True, True, False], "y": [1, 2, 0], "z": [9.2, 10.5, 11.8]})
+    df = df_from_dict(
+        {"x": [True, True, False], "y": [1, 2, 0], "z": [9.2, 10.5, 11.8]}
+    )
     dfX = df.__dataframe__()
 
     assert dfX.num_columns() == 3
     assert dfX.num_rows() == 3
     assert dfX.num_chunks() == 1
     assert dfX.column_names() == ["x", "y", "z"]
-    assert dfX.select_columns((0, 2)).column_names() == dfX.select_columns_by_name(("x", "z")).column_names()
+    assert (
+        dfX.select_columns((0, 2)).column_names()
+        == dfX.select_columns_by_name(("x", "z")).column_names()
+    )
+
 
 @pytest.mark.parametrize(["size", "n_chunks"], [(10, 3), (12, 3), (12, 5)])
 def test_df_get_chunks(size, n_chunks, df_from_dict):
@@ -81,6 +100,7 @@ def test_df_get_chunks(size, n_chunks, df_from_dict):
     assert len(chunks) == n_chunks
     assert sum(chunk.num_rows() for chunk in chunks) == size
 
+
 @pytest.mark.parametrize(["size", "n_chunks"], [(10, 3), (12, 3), (12, 5)])
 def test_column_get_chunks(size, n_chunks, df_from_dict):
     df = df_from_dict({"x": list(range(size))})
@@ -89,6 +109,7 @@ def test_column_get_chunks(size, n_chunks, df_from_dict):
     assert len(chunks) == n_chunks
     assert sum(chunk.size for chunk in chunks) == size
 
+
 def test_get_columns(df_from_dict):
     df = df_from_dict({"a": [0, 1], "b": [2.5, 3.5]})
     dfX = df.__dataframe__()
@@ -98,6 +119,7 @@ def test_get_columns(df_from_dict):
     assert dfX.get_column(0).dtype[0] == 0
     assert dfX.get_column(1).dtype[0] == 2
 
+
 def test_buffer(df_from_dict):
     arr = [0, 1, -1]
     df = df_from_dict({"a": arr})
@@ -113,12 +135,14 @@ def test_buffer(df_from_dict):
 
     assert dataDtype[0] == 0
 
-    if device == 1: # CPU-only as we're going to directly read memory here
+    if device == 1:  # CPU-only as we're going to directly read memory here
         bitwidth = dataDtype[1]
-        ctype = {8: ctypes.c_int8,
-                 16: ctypes.c_int16,
-                 32: ctypes.c_int32,
-                 64: ctypes.c_int64}[bitwidth]
+        ctype = {
+            8: ctypes.c_int8,
+            16: ctypes.c_int16,
+            32: ctypes.c_int32,
+            64: ctypes.c_int64,
+        }[bitwidth]
 
         for idx, truth in enumerate(arr):
             val = ctype.from_address(dataBuf.ptr + idx * (bitwidth // 8)).value