STYLE: inconsistent namespace (reshape)

Author: AA-Turner

pandas/tests/reshape/concat/test_concat.py

@@ -420,42 +420,42 @@ def __getitem__(self, index):
                 except KeyError as err:
                     raise IndexError from err
 
-        tm.assert_frame_equal(pd.concat(CustomIterator1(), ignore_index=True), expected)
+        tm.assert_frame_equal(concat(CustomIterator1(), ignore_index=True), expected)
 
         class CustomIterator2(abc.Iterable):
             def __iter__(self):
                 yield df1
                 yield df2
 
-        tm.assert_frame_equal(pd.concat(CustomIterator2(), ignore_index=True), expected)
+        tm.assert_frame_equal(concat(CustomIterator2(), ignore_index=True), expected)
 
     def test_concat_order(self):
         # GH 17344
         dfs = [DataFrame(index=range(3), columns=["a", 1, None])]
         dfs += [DataFrame(index=range(3), columns=[None, 1, "a"]) for i in range(100)]
 
-        result = pd.concat(dfs, sort=True).columns
+        result = concat(dfs, sort=True).columns
         expected = dfs[0].columns
         tm.assert_index_equal(result, expected)
 
     def test_concat_different_extension_dtypes_upcasts(self):
         a = Series(pd.array([1, 2], dtype="Int64"))
         b = Series(to_decimal([1, 2]))
 
-        result = pd.concat([a, b], ignore_index=True)
+        result = concat([a, b], ignore_index=True)
         expected = Series([1, 2, Decimal(1), Decimal(2)], dtype=object)
         tm.assert_series_equal(result, expected)
 
     def test_concat_ordered_dict(self):
         # GH 21510
-        expected = pd.concat(
+        expected = concat(
             [Series(range(3)), Series(range(4))], keys=["First", "Another"]
         )
-        result = pd.concat({"First": Series(range(3)), "Another": Series(range(4))})
+        result = concat({"First": Series(range(3)), "Another": Series(range(4))})
         tm.assert_series_equal(result, expected)
 
 
-@pytest.mark.parametrize("pdt", [Series, pd.DataFrame])
+@pytest.mark.parametrize("pdt", [Series, DataFrame])
 @pytest.mark.parametrize("dt", np.sctypes["float"])
 def test_concat_no_unnecessary_upcast(dt, pdt):
     # GH 13247
@@ -466,11 +466,11 @@ def test_concat_no_unnecessary_upcast(dt, pdt):
         pdt(np.array([np.nan], dtype=dt, ndmin=dims)),
         pdt(np.array([5], dtype=dt, ndmin=dims)),
     ]
-    x = pd.concat(dfs)
+    x = concat(dfs)
     assert x.values.dtype == dt
 
 
-@pytest.mark.parametrize("pdt", [create_series_with_explicit_dtype, pd.DataFrame])
+@pytest.mark.parametrize("pdt", [create_series_with_explicit_dtype, DataFrame])
 @pytest.mark.parametrize("dt", np.sctypes["int"])
 def test_concat_will_upcast(dt, pdt):
     with catch_warnings(record=True):
@@ -480,7 +480,7 @@ def test_concat_will_upcast(dt, pdt):
             pdt(np.array([np.nan], ndmin=dims)),
             pdt(np.array([5], dtype=dt, ndmin=dims)),
         ]
-        x = pd.concat(dfs)
+        x = concat(dfs)
         assert x.values.dtype == "float64"
 
 
@@ -489,7 +489,7 @@ def test_concat_empty_and_non_empty_frame_regression():
     df1 = DataFrame({"foo": [1]})
     df2 = DataFrame({"foo": []})
     expected = DataFrame({"foo": [1.0]})
-    result = pd.concat([df1, df2])
+    result = concat([df1, df2])
     tm.assert_frame_equal(result, expected)
 
 
@@ -499,7 +499,7 @@ def test_concat_sparse():
     expected = DataFrame(data=[[0, 0], [1, 1], [2, 2]]).astype(
         pd.SparseDtype(np.int64, 0)
     )
-    result = pd.concat([a, a], axis=1)
+    result = concat([a, a], axis=1)
     tm.assert_frame_equal(result, expected)
 
 
@@ -510,7 +510,7 @@ def test_concat_dense_sparse():
     expected = Series(data=[1, None, 1], index=[0, 1, 0]).astype(
         pd.SparseDtype(np.float64, None)
     )
-    result = pd.concat([a, b], axis=0)
+    result = concat([a, b], axis=0)
     tm.assert_series_equal(result, expected)
 
 
@@ -548,11 +548,11 @@ def test_concat_frame_axis0_extension_dtypes():
     df1 = DataFrame({"a": pd.array([1, 2, 3], dtype="Int64")})
     df2 = DataFrame({"a": np.array([4, 5, 6])})
 
-    result = pd.concat([df1, df2], ignore_index=True)
+    result = concat([df1, df2], ignore_index=True)
     expected = DataFrame({"a": [1, 2, 3, 4, 5, 6]}, dtype="Int64")
     tm.assert_frame_equal(result, expected)
 
-    result = pd.concat([df2, df1], ignore_index=True)
+    result = concat([df2, df1], ignore_index=True)
     expected = DataFrame({"a": [4, 5, 6, 1, 2, 3]}, dtype="Int64")
     tm.assert_frame_equal(result, expected)
 
@@ -561,7 +561,7 @@ def test_concat_preserves_extension_int64_dtype():
     # GH 24768
     df_a = DataFrame({"a": [-1]}, dtype="Int64")
     df_b = DataFrame({"b": [1]}, dtype="Int64")
-    result = pd.concat([df_a, df_b], ignore_index=True)
+    result = concat([df_a, df_b], ignore_index=True)
     expected = DataFrame({"a": [-1, None], "b": [None, 1]}, dtype="Int64")
     tm.assert_frame_equal(result, expected)
 

pandas/tests/reshape/concat/test_dataframe.py

@@ -17,7 +17,7 @@ def test_concat_multiple_frames_dtypes(self):
         # GH#2759
         A = DataFrame(data=np.ones((10, 2)), columns=["foo", "bar"], dtype=np.float64)
         B = DataFrame(data=np.ones((10, 2)), dtype=np.float32)
-        results = pd.concat((A, B), axis=1).dtypes
+        results = concat((A, B), axis=1).dtypes
         expected = Series(
             [np.dtype("float64")] * 2 + [np.dtype("float32")] * 2,
             index=["foo", "bar", 0, 1],
@@ -28,7 +28,7 @@ def test_concat_tuple_keys(self):
         # GH#14438
         df1 = DataFrame(np.ones((2, 2)), columns=list("AB"))
         df2 = DataFrame(np.ones((3, 2)) * 2, columns=list("AB"))
-        results = pd.concat((df1, df2), keys=[("bee", "bah"), ("bee", "boo")])
+        results = concat((df1, df2), keys=[("bee", "bah"), ("bee", "boo")])
         expected = DataFrame(
             {
                 "A": {
@@ -53,20 +53,18 @@ def test_concat_named_keys(self):
         # GH#14252
         df = DataFrame({"foo": [1, 2], "bar": [0.1, 0.2]})
         index = Index(["a", "b"], name="baz")
-        concatted_named_from_keys = pd.concat([df, df], keys=index)
+        concatted_named_from_keys = concat([df, df], keys=index)
         expected_named = DataFrame(
             {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]},
             index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=["baz", None]),
         )
         tm.assert_frame_equal(concatted_named_from_keys, expected_named)
 
         index_no_name = Index(["a", "b"], name=None)
-        concatted_named_from_names = pd.concat(
-            [df, df], keys=index_no_name, names=["baz"]
-        )
+        concatted_named_from_names = concat([df, df], keys=index_no_name, names=["baz"])
         tm.assert_frame_equal(concatted_named_from_names, expected_named)
 
-        concatted_unnamed = pd.concat([df, df], keys=index_no_name)
+        concatted_unnamed = concat([df, df], keys=index_no_name)
         expected_unnamed = DataFrame(
             {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]},
             index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=[None, None]),
@@ -81,24 +79,24 @@ def test_concat_axis_parameter(self):
         # Index/row/0 DataFrame
         expected_index = DataFrame({"A": [0.1, 0.2, 0.3, 0.4]}, index=[0, 1, 0, 1])
 
-        concatted_index = pd.concat([df1, df2], axis="index")
+        concatted_index = concat([df1, df2], axis="index")
         tm.assert_frame_equal(concatted_index, expected_index)
 
-        concatted_row = pd.concat([df1, df2], axis="rows")
+        concatted_row = concat([df1, df2], axis="rows")
         tm.assert_frame_equal(concatted_row, expected_index)
 
-        concatted_0 = pd.concat([df1, df2], axis=0)
+        concatted_0 = concat([df1, df2], axis=0)
         tm.assert_frame_equal(concatted_0, expected_index)
 
         # Columns/1 DataFrame
         expected_columns = DataFrame(
             [[0.1, 0.3], [0.2, 0.4]], index=[0, 1], columns=["A", "A"]
         )
 
-        concatted_columns = pd.concat([df1, df2], axis="columns")
+        concatted_columns = concat([df1, df2], axis="columns")
         tm.assert_frame_equal(concatted_columns, expected_columns)
 
-        concatted_1 = pd.concat([df1, df2], axis=1)
+        concatted_1 = concat([df1, df2], axis=1)
         tm.assert_frame_equal(concatted_1, expected_columns)
 
         series1 = Series([0.1, 0.2])
@@ -107,29 +105,29 @@ def test_concat_axis_parameter(self):
         # Index/row/0 Series
         expected_index_series = Series([0.1, 0.2, 0.3, 0.4], index=[0, 1, 0, 1])
 
-        concatted_index_series = pd.concat([series1, series2], axis="index")
+        concatted_index_series = concat([series1, series2], axis="index")
         tm.assert_series_equal(concatted_index_series, expected_index_series)
 
-        concatted_row_series = pd.concat([series1, series2], axis="rows")
+        concatted_row_series = concat([series1, series2], axis="rows")
         tm.assert_series_equal(concatted_row_series, expected_index_series)
 
-        concatted_0_series = pd.concat([series1, series2], axis=0)
+        concatted_0_series = concat([series1, series2], axis=0)
         tm.assert_series_equal(concatted_0_series, expected_index_series)
 
         # Columns/1 Series
         expected_columns_series = DataFrame(
             [[0.1, 0.3], [0.2, 0.4]], index=[0, 1], columns=[0, 1]
         )
 
-        concatted_columns_series = pd.concat([series1, series2], axis="columns")
+        concatted_columns_series = concat([series1, series2], axis="columns")
         tm.assert_frame_equal(concatted_columns_series, expected_columns_series)
 
-        concatted_1_series = pd.concat([series1, series2], axis=1)
+        concatted_1_series = concat([series1, series2], axis=1)
         tm.assert_frame_equal(concatted_1_series, expected_columns_series)
 
         # Testing ValueError
         with pytest.raises(ValueError, match="No axis named"):
-            pd.concat([series1, series2], axis="something")
+            concat([series1, series2], axis="something")
 
     def test_concat_numerical_names(self):
         # GH#15262, GH#12223
@@ -142,7 +140,7 @@ def test_concat_numerical_names(self):
                 )
             ),
         )
-        result = pd.concat((df.iloc[:2, :], df.iloc[-2:, :]))
+        result = concat((df.iloc[:2, :], df.iloc[-2:, :]))
         expected = DataFrame(
             {"col": [0, 1, 7, 8]},
             dtype="int32",
@@ -155,7 +153,7 @@ def test_concat_numerical_names(self):
     def test_concat_astype_dup_col(self):
         # GH#23049
         df = DataFrame([{"a": "b"}])
-        df = pd.concat([df, df], axis=1)
+        df = concat([df, df], axis=1)
 
         result = df.astype("category")
         expected = DataFrame(