From c46a09e99ea3b25bbd4b152852d5f731dd6c56ae Mon Sep 17 00:00:00 2001
From: Sydney Hughes <sydneyeh@umich.edu>
Date: Fri, 15 Apr 2022 16:40:20 -0400
Subject: [PATCH 1/7] changes made to
 pandas/core/groupby/ops.py/_call_cython_ops() and new file added in
 pandas/tests/groupby/test_groupby_last.py, issue #46409

---
 pandas/core/groupby/ops.py                |    5 +
 pandas/tests/groupby/test_groupby_last.py | 1291 +++++++++++++++++++++
 2 files changed, 1296 insertions(+)
 create mode 100644 pandas/tests/groupby/test_groupby_last.py

diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index b43319765c5b4..6d6f89f7a0b20 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -577,6 +577,11 @@ def _call_cython_op(
                     **kwargs,
                 )
 
+        if self.how == 'last' and dtype == bool:
+            for val in result:
+                if val > 1 or val < 0:
+                    result = values
+
         if self.kind == "aggregate":
             # i.e. counts is defined.  Locations where count<min_count
             # need to have the result set to np.nan, which may require casting,
diff --git a/pandas/tests/groupby/test_groupby_last.py b/pandas/tests/groupby/test_groupby_last.py
new file mode 100644
index 0000000000000..74309bc6e771d
--- /dev/null
+++ b/pandas/tests/groupby/test_groupby_last.py
@@ -0,0 +1,1291 @@
+import pandas as pd
+
+# start at top of doc
+# need 111 tests (end on test_group_last_use_ops_110())
+# top starts with failing tests
+# download and link file in final report
+
+### START ARRAY LENGTH 4, FAIL ###
+def test_group_last_use_ops_0():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, True, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype() 
+
+def test_group_last_use_ops_1():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, True, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_2():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, True, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_3():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, False, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_4():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, False, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_5():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, False, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_6():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, True, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_6():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, False, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_7():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_8():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_9():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_10():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_11():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_12():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_13():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_14():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_15():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_16():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_17():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_18():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_19():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, pd.NA, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_20():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, pd.NA, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_21():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, pd.NA, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_22():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, pd.NA, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_23():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, pd.NA, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_24():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, pd.NA, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 4, FAIL ####
+
+
+### START ARRAY LENGTH 5, FAIL ###
+def test_group_last_use_ops_26():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, True, pd.NA, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_27():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, False, pd.NA, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_28():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, True, True, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_29():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, False, False, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_30():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, True, True, True, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_31():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, False, False, False, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_32():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, True, pd.NA, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_33():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, False, pd.NA, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_34():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, True, True, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_35():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, False, False, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_36():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [pd.NA, pd.NA, pd.NA, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_37():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [pd.NA, pd.NA, pd.NA, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_38():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, True, pd.NA, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_39():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, False, pd.NA, pd.NA, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 5, FAIL ###
+
+
+### START ARRAY LENGTH 6, FAIL ###
+def test_group_last_use_ops_40():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, True, pd.NA, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_41():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, False, pd.NA, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_42():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, True, True, pd.NA, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_43():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, False, False, pd.NA, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_44():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, True, True, True, pd.NA, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_45():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, False, False, False, pd.NA, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_46():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, True, True, True, True, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_47():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, False, False, False, False, pd.NA]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_48():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, pd.NA, pd.NA, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_49():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, pd.NA, pd.NA, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_50():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, True, pd.NA, pd.NA, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_51():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, False, pd.NA, pd.NA, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_52():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [pd.NA, pd.NA, pd.NA, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_53():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [pd.NA, pd.NA, pd.NA, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 6, FAIL ###
+
+
+### START ARRAY LENGTH 20, FAIL ###
+def test_group_last_use_ops_55():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [True, True, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_56():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [False, False, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_57():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [True, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_58():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [False, pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_59():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [True, True, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_60():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [False, False, pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_61():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [pd.NA, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_62():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [pd.NA, pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 20, FAIL ###
+
+
+### START ARRY LENGTH 4, PASS ###
+def test_group_last_use_ops_63():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_64():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_65():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_66():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, True, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_67():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, False, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_68():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, True, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_69():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, False, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_70():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, False, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_71():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_72():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, False, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_73():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, True, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_74():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, True, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_75():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_76():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, False, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_77():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, False, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_78():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_79():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [pd.NA, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_80():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [pd.NA, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_81():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [True, pd.NA, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_82():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [False, pd.NA, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_83():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [pd.NA, pd.NA, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_84():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [pd.NA, pd.NA, True, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_85():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [pd.NA, pd.NA, False, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_86():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4],
+            'test': [pd.NA, pd.NA, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 4, PASS ###
+
+
+### START ARRAY LENGTH 5, PASS ###
+def test_group_last_use_ops_87():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_88():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_89():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [pd.NA, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_90():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [pd.NA, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_91():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [True, pd.NA, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_92():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [False, pd.NA, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_93():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [pd.NA, pd.NA, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_94():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5],
+            'test': [pd.NA, pd.NA, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 5, PASS ###
+
+
+### START ARRAY LENGTH 6, PASS ### 
+def test_group_last_use_ops_95():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_96():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_97():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [pd.NA, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_98():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [pd.NA, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_99():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [True, pd.NA, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_100():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [False, pd.NA, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_101():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [pd.NA, pd.NA, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_102():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6],
+            'test': [pd.NA, pd.NA, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 6, PASS ### 
+
+
+### START ARRAY LENGTH 20, PASS ###
+def test_group_last_use_ops_103():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_104():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_105():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_106():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_107():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [True, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_108():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [False, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+
+def test_group_last_use_ops_109():
+    df = pd.DataFrame(
+        {
+            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+            'test': [pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+        }
+    ).convert_dtypes()
+    grouped = df.groupby('id')
+    bad = grouped.last()
+    
+    assert bad.test.dtype == pd.BooleanDtype()
+### END ARRAY LENGTH 20, PASS ###
+### END ORIGNAL TEST SUITE, FAIL: 62 PASS: 47 ###
+

From 4e8bcaf84e366ab3e232e59e97fb09d1cabf4bcd Mon Sep 17 00:00:00 2001
From: Sydney Hughes <sydneyeh@umich.edu>
Date: Fri, 15 Apr 2022 16:58:43 -0400
Subject: [PATCH 2/7] changes to v1.5.0.rst

---
 doc/source/whatsnew/v1.5.0.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 8607294244052..2ec142fe7e423 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -453,7 +453,7 @@ Performance improvements
 .. _whatsnew_150.bug_fixes:
 
 Bug fixes
-~~~~~~~~~
+- Bug in :func:`_call_cython_op` that caused numpy arrays ordered with last with pd.NA to have dytype:Int64 type rather than dtype:Bool (:issue:`46409`)
 
 Categorical
 ^^^^^^^^^^^
@@ -473,12 +473,12 @@ Datetimelike
 
 Timedelta
 ^^^^^^^^^
-- Bug in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
+- Bug FIXED in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
+- 
 
 Time Zones
 ^^^^^^^^^^
 -
--
 
 Numeric
 ^^^^^^^

From 9c1ce0ab297bce8f37499f242d4b3b3d5dfc6d70 Mon Sep 17 00:00:00 2001
From: Sydney Hughes <sydneyeh@umich.edu>
Date: Fri, 15 Apr 2022 17:14:56 -0400
Subject: [PATCH 3/7] style checks

---
 pandas/tests/groupby/test_groupby_last.py | 166 +++++++++++++++++-----
 1 file changed, 130 insertions(+), 36 deletions(-)

diff --git a/pandas/tests/groupby/test_groupby_last.py b/pandas/tests/groupby/test_groupby_last.py
index 74309bc6e771d..b582dbc7dfa76 100644
--- a/pandas/tests/groupby/test_groupby_last.py
+++ b/pandas/tests/groupby/test_groupby_last.py
@@ -1,11 +1,6 @@
 import pandas as pd
 
-# start at top of doc
-# need 111 tests (end on test_group_last_use_ops_110())
-# top starts with failing tests
-# download and link file in final report
 
-### START ARRAY LENGTH 4, FAIL ###
 def test_group_last_use_ops_0():
     df = pd.DataFrame(
         {
@@ -17,6 +12,7 @@ def test_group_last_use_ops_0():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype() 
 
+
 def test_group_last_use_ops_1():
     df = pd.DataFrame(
         {
@@ -28,6 +24,7 @@ def test_group_last_use_ops_1():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_2():
     df = pd.DataFrame(
         {
@@ -39,6 +36,7 @@ def test_group_last_use_ops_2():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_3():
     df = pd.DataFrame(
         {
@@ -50,6 +48,7 @@ def test_group_last_use_ops_3():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_4():
     df = pd.DataFrame(
         {
@@ -61,6 +60,7 @@ def test_group_last_use_ops_4():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_5():
     df = pd.DataFrame(
         {
@@ -72,6 +72,7 @@ def test_group_last_use_ops_5():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_6():
     df = pd.DataFrame(
         {
@@ -83,6 +84,7 @@ def test_group_last_use_ops_6():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_6():
     df = pd.DataFrame(
         {
@@ -94,6 +96,7 @@ def test_group_last_use_ops_6():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_7():
     df = pd.DataFrame(
         {
@@ -105,6 +108,7 @@ def test_group_last_use_ops_7():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_8():
     df = pd.DataFrame(
         {
@@ -127,6 +131,7 @@ def test_group_last_use_ops_9():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_10():
     df = pd.DataFrame(
         {
@@ -138,6 +143,7 @@ def test_group_last_use_ops_10():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_11():
     df = pd.DataFrame(
         {
@@ -149,6 +155,7 @@ def test_group_last_use_ops_11():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_12():
     df = pd.DataFrame(
         {
@@ -160,6 +167,7 @@ def test_group_last_use_ops_12():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_13():
     df = pd.DataFrame(
         {
@@ -171,6 +179,7 @@ def test_group_last_use_ops_13():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_14():
     df = pd.DataFrame(
         {
@@ -182,6 +191,7 @@ def test_group_last_use_ops_14():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_15():
     df = pd.DataFrame(
         {
@@ -193,6 +203,7 @@ def test_group_last_use_ops_15():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_16():
     df = pd.DataFrame(
         {
@@ -204,6 +215,7 @@ def test_group_last_use_ops_16():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_17():
     df = pd.DataFrame(
         {
@@ -215,6 +227,7 @@ def test_group_last_use_ops_17():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_18():
     df = pd.DataFrame(
         {
@@ -226,6 +239,7 @@ def test_group_last_use_ops_18():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_19():
     df = pd.DataFrame(
         {
@@ -237,6 +251,7 @@ def test_group_last_use_ops_19():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_20():
     df = pd.DataFrame(
         {
@@ -248,6 +263,7 @@ def test_group_last_use_ops_20():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_21():
     df = pd.DataFrame(
         {
@@ -259,6 +275,7 @@ def test_group_last_use_ops_21():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_22():
     df = pd.DataFrame(
         {
@@ -270,6 +287,7 @@ def test_group_last_use_ops_22():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_23():
     df = pd.DataFrame(
         {
@@ -281,6 +299,7 @@ def test_group_last_use_ops_23():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_24():
     df = pd.DataFrame(
         {
@@ -291,10 +310,9 @@ def test_group_last_use_ops_24():
     grouped = df.groupby('id')
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 4, FAIL ####
 
 
-### START ARRAY LENGTH 5, FAIL ###
+
 def test_group_last_use_ops_26():
     df = pd.DataFrame(
         {
@@ -306,6 +324,7 @@ def test_group_last_use_ops_26():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_27():
     df = pd.DataFrame(
         {
@@ -317,6 +336,7 @@ def test_group_last_use_ops_27():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_28():
     df = pd.DataFrame(
         {
@@ -328,6 +348,7 @@ def test_group_last_use_ops_28():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_29():
     df = pd.DataFrame(
         {
@@ -339,6 +360,7 @@ def test_group_last_use_ops_29():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_30():
     df = pd.DataFrame(
         {
@@ -350,6 +372,7 @@ def test_group_last_use_ops_30():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_31():
     df = pd.DataFrame(
         {
@@ -361,6 +384,7 @@ def test_group_last_use_ops_31():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_32():
     df = pd.DataFrame(
         {
@@ -372,6 +396,7 @@ def test_group_last_use_ops_32():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_33():
     df = pd.DataFrame(
         {
@@ -383,6 +408,7 @@ def test_group_last_use_ops_33():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_34():
     df = pd.DataFrame(
         {
@@ -394,6 +420,7 @@ def test_group_last_use_ops_34():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_35():
     df = pd.DataFrame(
         {
@@ -405,6 +432,7 @@ def test_group_last_use_ops_35():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_36():
     df = pd.DataFrame(
         {
@@ -416,6 +444,7 @@ def test_group_last_use_ops_36():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_37():
     df = pd.DataFrame(
         {
@@ -427,6 +456,7 @@ def test_group_last_use_ops_37():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_38():
     df = pd.DataFrame(
         {
@@ -438,6 +468,7 @@ def test_group_last_use_ops_38():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_39():
     df = pd.DataFrame(
         {
@@ -448,10 +479,8 @@ def test_group_last_use_ops_39():
     grouped = df.groupby('id')
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 5, FAIL ###
 
 
-### START ARRAY LENGTH 6, FAIL ###
 def test_group_last_use_ops_40():
     df = pd.DataFrame(
         {
@@ -463,6 +492,7 @@ def test_group_last_use_ops_40():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_41():
     df = pd.DataFrame(
         {
@@ -474,6 +504,7 @@ def test_group_last_use_ops_41():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_42():
     df = pd.DataFrame(
         {
@@ -485,6 +516,7 @@ def test_group_last_use_ops_42():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_43():
     df = pd.DataFrame(
         {
@@ -496,6 +528,7 @@ def test_group_last_use_ops_43():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_44():
     df = pd.DataFrame(
         {
@@ -507,6 +540,7 @@ def test_group_last_use_ops_44():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_45():
     df = pd.DataFrame(
         {
@@ -518,6 +552,7 @@ def test_group_last_use_ops_45():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_46():
     df = pd.DataFrame(
         {
@@ -529,6 +564,7 @@ def test_group_last_use_ops_46():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_47():
     df = pd.DataFrame(
         {
@@ -540,6 +576,7 @@ def test_group_last_use_ops_47():
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_48():
     df = pd.DataFrame(
         {
@@ -552,6 +589,7 @@ def test_group_last_use_ops_48():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_49():
     df = pd.DataFrame(
         {
@@ -564,6 +602,7 @@ def test_group_last_use_ops_49():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_50():
     df = pd.DataFrame(
         {
@@ -576,6 +615,7 @@ def test_group_last_use_ops_50():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_51():
     df = pd.DataFrame(
         {
@@ -588,6 +628,7 @@ def test_group_last_use_ops_51():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_52():
     df = pd.DataFrame(
         {
@@ -600,6 +641,7 @@ def test_group_last_use_ops_52():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_53():
     df = pd.DataFrame(
         {
@@ -611,15 +653,14 @@ def test_group_last_use_ops_53():
     bad = grouped.last()
     
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 6, FAIL ###
 
 
-### START ARRAY LENGTH 20, FAIL ###
 def test_group_last_use_ops_55():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+            'test': [True, True, pd.NA, True, True, True, True, True, True, True, True, True,
+                     True, True, True, True, True, True, True, True]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -627,11 +668,13 @@ def test_group_last_use_ops_55():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_56():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [False, False, pd.NA, False, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -639,11 +682,13 @@ def test_group_last_use_ops_56():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_57():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+            'test': [True, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True,
+                     True, True, True, True, True, True, True, True]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -651,11 +696,13 @@ def test_group_last_use_ops_57():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_58():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [False, pd.NA, pd.NA, False, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -663,11 +710,13 @@ def test_group_last_use_ops_58():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_59():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+            'test': [True, True, pd.NA, pd.NA, True, True, True, True, True, True, True, True,
+                     True, True, True, True, True, True, True, True]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -675,11 +724,13 @@ def test_group_last_use_ops_59():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_60():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [False, False, pd.NA, pd.NA, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -687,11 +738,13 @@ def test_group_last_use_ops_60():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_61():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+            'test': [pd.NA, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True,
+                     True, True, True, True, True, True, True, True]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -699,21 +752,21 @@ def test_group_last_use_ops_61():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_62():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [pd.NA, pd.NA, pd.NA, False, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
     bad = grouped.last()
     
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 20, FAIL ###
 
 
-### START ARRY LENGTH 4, PASS ###
 def test_group_last_use_ops_63():
     df = pd.DataFrame(
         {
@@ -726,6 +779,7 @@ def test_group_last_use_ops_63():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_64():
     df = pd.DataFrame(
         {
@@ -738,6 +792,7 @@ def test_group_last_use_ops_64():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_65():
     df = pd.DataFrame(
         {
@@ -750,6 +805,7 @@ def test_group_last_use_ops_65():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_66():
     df = pd.DataFrame(
         {
@@ -762,6 +818,7 @@ def test_group_last_use_ops_66():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_67():
     df = pd.DataFrame(
         {
@@ -774,6 +831,7 @@ def test_group_last_use_ops_67():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_68():
     df = pd.DataFrame(
         {
@@ -786,6 +844,7 @@ def test_group_last_use_ops_68():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_69():
     df = pd.DataFrame(
         {
@@ -798,6 +857,7 @@ def test_group_last_use_ops_69():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_70():
     df = pd.DataFrame(
         {
@@ -810,6 +870,7 @@ def test_group_last_use_ops_70():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_71():
     df = pd.DataFrame(
         {
@@ -822,6 +883,7 @@ def test_group_last_use_ops_71():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_72():
     df = pd.DataFrame(
         {
@@ -834,6 +896,7 @@ def test_group_last_use_ops_72():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_73():
     df = pd.DataFrame(
         {
@@ -846,6 +909,7 @@ def test_group_last_use_ops_73():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_74():
     df = pd.DataFrame(
         {
@@ -858,6 +922,7 @@ def test_group_last_use_ops_74():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_75():
     df = pd.DataFrame(
         {
@@ -870,6 +935,7 @@ def test_group_last_use_ops_75():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_76():
     df = pd.DataFrame(
         {
@@ -882,6 +948,7 @@ def test_group_last_use_ops_76():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_77():
     df = pd.DataFrame(
         {
@@ -894,6 +961,7 @@ def test_group_last_use_ops_77():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_78():
     df = pd.DataFrame(
         {
@@ -906,6 +974,7 @@ def test_group_last_use_ops_78():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_79():
     df = pd.DataFrame(
         {
@@ -918,6 +987,7 @@ def test_group_last_use_ops_79():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_80():
     df = pd.DataFrame(
         {
@@ -930,6 +1000,7 @@ def test_group_last_use_ops_80():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_81():
     df = pd.DataFrame(
         {
@@ -942,6 +1013,7 @@ def test_group_last_use_ops_81():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_82():
     df = pd.DataFrame(
         {
@@ -954,6 +1026,7 @@ def test_group_last_use_ops_82():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_83():
     df = pd.DataFrame(
         {
@@ -966,6 +1039,7 @@ def test_group_last_use_ops_83():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_84():
     df = pd.DataFrame(
         {
@@ -978,6 +1052,7 @@ def test_group_last_use_ops_84():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_85():
     df = pd.DataFrame(
         {
@@ -990,6 +1065,7 @@ def test_group_last_use_ops_85():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_86():
     df = pd.DataFrame(
         {
@@ -1001,10 +1077,8 @@ def test_group_last_use_ops_86():
     bad = grouped.last()
     
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 4, PASS ###
 
 
-### START ARRAY LENGTH 5, PASS ###
 def test_group_last_use_ops_87():
     df = pd.DataFrame(
         {
@@ -1017,6 +1091,7 @@ def test_group_last_use_ops_87():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_88():
     df = pd.DataFrame(
         {
@@ -1029,6 +1104,7 @@ def test_group_last_use_ops_88():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_89():
     df = pd.DataFrame(
         {
@@ -1041,6 +1117,7 @@ def test_group_last_use_ops_89():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_90():
     df = pd.DataFrame(
         {
@@ -1053,6 +1130,7 @@ def test_group_last_use_ops_90():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_91():
     df = pd.DataFrame(
         {
@@ -1065,6 +1143,7 @@ def test_group_last_use_ops_91():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_92():
     df = pd.DataFrame(
         {
@@ -1077,6 +1156,7 @@ def test_group_last_use_ops_92():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_93():
     df = pd.DataFrame(
         {
@@ -1089,6 +1169,7 @@ def test_group_last_use_ops_93():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_94():
     df = pd.DataFrame(
         {
@@ -1100,10 +1181,8 @@ def test_group_last_use_ops_94():
     bad = grouped.last()
     
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 5, PASS ###
 
 
-### START ARRAY LENGTH 6, PASS ### 
 def test_group_last_use_ops_95():
     df = pd.DataFrame(
         {
@@ -1116,6 +1195,7 @@ def test_group_last_use_ops_95():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_96():
     df = pd.DataFrame(
         {
@@ -1128,6 +1208,7 @@ def test_group_last_use_ops_96():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_97():
     df = pd.DataFrame(
         {
@@ -1140,6 +1221,7 @@ def test_group_last_use_ops_97():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_98():
     df = pd.DataFrame(
         {
@@ -1152,6 +1234,7 @@ def test_group_last_use_ops_98():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_99():
     df = pd.DataFrame(
         {
@@ -1164,6 +1247,7 @@ def test_group_last_use_ops_99():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_100():
     df = pd.DataFrame(
         {
@@ -1188,6 +1272,7 @@ def test_group_last_use_ops_101():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_102():
     df = pd.DataFrame(
         {
@@ -1199,15 +1284,14 @@ def test_group_last_use_ops_102():
     bad = grouped.last()
     
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 6, PASS ### 
 
 
-### START ARRAY LENGTH 20, PASS ###
 def test_group_last_use_ops_103():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+            'test': [True, True, True, True, True, True, True, True, True, True, True, True,
+                     True, True, True, True, True, True, True, True]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -1215,11 +1299,13 @@ def test_group_last_use_ops_103():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_104():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [False, False, False, False, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -1227,11 +1313,13 @@ def test_group_last_use_ops_104():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_105():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+            'test': [pd.NA, True, True, True, True, True, True, True, True, True, True, True,
+                     True, True, True, True, True, True, True, True]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -1239,11 +1327,13 @@ def test_group_last_use_ops_105():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_106():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [pd.NA, False, False, False, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -1251,11 +1341,13 @@ def test_group_last_use_ops_106():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_107():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, pd.NA, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]
+            'test': [True, pd.NA, True, True, True, True, True, True, True, True, True, True,
+                     True, True, True, True, True, True, True, True]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -1263,11 +1355,13 @@ def test_group_last_use_ops_107():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_108():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [False, pd.NA, False, False, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
@@ -1275,17 +1369,17 @@ def test_group_last_use_ops_108():
     
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_109():
     df = pd.DataFrame(
         {
             'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
+            'test': [pd.NA, pd.NA, False, False, False, False, False, False, False, False,
+                     False, False, False, False, False, False, False, False, False, False]
         }
     ).convert_dtypes()
     grouped = df.groupby('id')
     bad = grouped.last()
     
     assert bad.test.dtype == pd.BooleanDtype()
-### END ARRAY LENGTH 20, PASS ###
-### END ORIGNAL TEST SUITE, FAIL: 62 PASS: 47 ###
 

From 30e6456d8b03dab1e122c4431d01309a9e43a43c Mon Sep 17 00:00:00 2001
From: Sydney Hughes <55883079+sydneyeh@users.noreply.github.com>
Date: Sat, 16 Apr 2022 15:39:51 +0000
Subject: [PATCH 4/7] Fixes from pre-commit [automated commit]

---
 doc/source/whatsnew/v1.5.0.rst            |    2 +-
 pandas/core/groupby/ops.py                |    2 +-
 pandas/tests/groupby/test_groupby_last.py | 1581 +++++++++++++--------
 3 files changed, 959 insertions(+), 626 deletions(-)

diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index fd59b28f2e62f..5fdec123ec6be 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -478,7 +478,7 @@ Datetimelike
 Timedelta
 ^^^^^^^^^
 - Bug FIXED in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
-- 
+-
 
 Time Zones
 ^^^^^^^^^^
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index c3607b05ae0c0..c48f310559ddb 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -571,7 +571,7 @@ def _call_cython_op(
                     **kwargs,
                 )
 
-        if self.how == 'last' and dtype == bool:
+        if self.how == "last" and dtype == bool:
             for val in result:
                 if val > 1 or val < 0:
                     result = values
diff --git a/pandas/tests/groupby/test_groupby_last.py b/pandas/tests/groupby/test_groupby_last.py
index b582dbc7dfa76..43f5eb0c21df0 100644
--- a/pandas/tests/groupby/test_groupby_last.py
+++ b/pandas/tests/groupby/test_groupby_last.py
@@ -3,1383 +3,1716 @@
 
 def test_group_last_use_ops_0():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, True, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, True, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype() 
+    assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_1():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, True, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, True, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_2():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, True, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, True, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_3():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, False, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, False, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_4():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, False, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, False, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_5():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, False, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, False, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_6():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, True, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, True, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_6():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, False, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, False, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_7():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_8():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_9():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_10():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_11():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_12():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_13():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_14():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_15():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_16():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_17():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_18():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_19():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, pd.NA, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_20():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, pd.NA, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_21():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, pd.NA, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_22():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, pd.NA, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_23():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, pd.NA, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_24():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, pd.NA, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
-
 def test_group_last_use_ops_26():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, pd.NA, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, True, pd.NA, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_27():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, pd.NA, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, False, pd.NA, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_28():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, True, True, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_29():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, False, False, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_30():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, True, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, True, True, True, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_31():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, False, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, False, False, False, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_32():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, pd.NA, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, True, pd.NA, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_33():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, pd.NA, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, False, pd.NA, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_34():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, True, True, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_35():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, False, False, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_36():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, pd.NA, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [pd.NA, pd.NA, pd.NA, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_37():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, pd.NA, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [pd.NA, pd.NA, pd.NA, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_38():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, pd.NA, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, True, pd.NA, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_39():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, pd.NA, pd.NA, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, False, pd.NA, pd.NA, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_40():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, pd.NA, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, True, pd.NA, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_41():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, pd.NA, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, False, pd.NA, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_42():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, pd.NA, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, True, True, pd.NA, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_43():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, pd.NA, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, False, False, pd.NA, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_44():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, True, pd.NA, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, True, True, True, pd.NA, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_45():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, False, pd.NA, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, False, False, False, pd.NA, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_46():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, True, True, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, True, True, True, True, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_47():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, False, False, pd.NA]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, False, False, False, False, pd.NA]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_48():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, pd.NA, pd.NA, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, pd.NA, pd.NA, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_49():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, pd.NA, pd.NA, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, pd.NA, pd.NA, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_50():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, pd.NA, pd.NA, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, True, pd.NA, pd.NA, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_51():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, pd.NA, pd.NA, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, False, pd.NA, pd.NA, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_52():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, pd.NA, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [pd.NA, pd.NA, pd.NA, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_53():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, pd.NA, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [pd.NA, pd.NA, pd.NA, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_55():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, pd.NA, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                True,
+                True,
+                pd.NA,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_56():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, pd.NA, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                False,
+                False,
+                pd.NA,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_57():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                True,
+                pd.NA,
+                pd.NA,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_58():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, pd.NA, pd.NA, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                False,
+                pd.NA,
+                pd.NA,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_59():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, pd.NA, pd.NA, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                True,
+                True,
+                pd.NA,
+                pd.NA,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_60():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, pd.NA, pd.NA, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                False,
+                False,
+                pd.NA,
+                pd.NA,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_61():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                pd.NA,
+                pd.NA,
+                pd.NA,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_62():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, pd.NA, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                pd.NA,
+                pd.NA,
+                pd.NA,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_63():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, False, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_64():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, False, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_65():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, False, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_66():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, True, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, True, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_67():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, False, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, False, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_68():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, True, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, True, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_69():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, False, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, False, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_70():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, True, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, False, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_71():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, False, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_72():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, False, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, False, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_73():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, True, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, True, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_74():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, True, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, True, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_75():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, True, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_76():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, True, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, False, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_77():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, False, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, False, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_78():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, True, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_79():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, True, True, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [pd.NA, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_80():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, False, False, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [pd.NA, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_81():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, True, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [True, pd.NA, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_82():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, False, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [False, pd.NA, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_83():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, True, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [pd.NA, pd.NA, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_84():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, True, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [pd.NA, pd.NA, True, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_85():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, False, True]
-        }
+        {"id": [1, 2, 3, 4], "test": [pd.NA, pd.NA, False, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_86():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, False, False]
-        }
+        {"id": [1, 2, 3, 4], "test": [pd.NA, pd.NA, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_87():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, True, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_88():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, False, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_89():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, True, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [pd.NA, True, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_90():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, False, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [pd.NA, False, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_91():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, pd.NA, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [True, pd.NA, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_92():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, pd.NA, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [False, pd.NA, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_93():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [pd.NA, pd.NA, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_94():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5], "test": [pd.NA, pd.NA, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_95():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, True, True, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_96():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, False, False, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_97():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, True, True, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [pd.NA, True, True, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_98():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, False, False, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [pd.NA, False, False, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_99():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, pd.NA, True, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [True, pd.NA, True, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_100():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, pd.NA, False, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [False, pd.NA, False, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
+
 def test_group_last_use_ops_101():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, True, True, True, True]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [pd.NA, pd.NA, True, True, True, True]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_102():
     df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, False, False, False, False]
-        }
+        {"id": [1, 2, 3, 4, 5, 6], "test": [pd.NA, pd.NA, False, False, False, False]}
     ).convert_dtypes()
-    grouped = df.groupby('id')
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_103():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, True, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_104():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_105():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, True, True, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                pd.NA,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_106():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, False, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                pd.NA,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_107():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, pd.NA, True, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                True,
+                pd.NA,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+                True,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_108():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, pd.NA, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                False,
+                pd.NA,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
+
     assert bad.test.dtype == pd.BooleanDtype()
 
 
 def test_group_last_use_ops_109():
     df = pd.DataFrame(
         {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
+            "id": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+            ],
+            "test": [
+                pd.NA,
+                pd.NA,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            ],
+        }
+    ).convert_dtypes()
+    grouped = df.groupby("id")
     bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
 
+    assert bad.test.dtype == pd.BooleanDtype()

From 9180dca7742e94fd59a9c871cb50a01963b994a1 Mon Sep 17 00:00:00 2001
From: Sydney Hughes <sydneyeh@umich.edu>
Date: Sat, 16 Apr 2022 11:45:20 -0400
Subject: [PATCH 5/7] fix in v1.5.0.rst and eliminate for loop in ops.py

---
 doc/source/whatsnew/v1.5.0.rst | 3 ++-
 pandas/core/groupby/ops.py     | 4 +---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 2ec142fe7e423..edb3c823b2127 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -453,7 +453,8 @@ Performance improvements
 .. _whatsnew_150.bug_fixes:
 
 Bug fixes
-- Bug in :func:`_call_cython_op` that caused numpy arrays ordered with last with pd.NA to have dytype:Int64 type rather than dtype:Bool (:issue:`46409`)
+^^^^^^^^^
+- Bug in :func:`gropuby.last()` that caused numpy arrays ordered with last with pd.NA to have dytype:Int64 type rather than dtype:Bool (:issue:`46409`)
 
 Categorical
 ^^^^^^^^^^^
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 6d6f89f7a0b20..85f14c47a9e44 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -578,9 +578,7 @@ def _call_cython_op(
                 )
 
         if self.how == 'last' and dtype == bool:
-            for val in result:
-                if val > 1 or val < 0:
-                    result = values
+            result = values
 
         if self.kind == "aggregate":
             # i.e. counts is defined.  Locations where count<min_count

From b86b52553132897ad5747e343842a29ebac176c0 Mon Sep 17 00:00:00 2001
From: Sydney Hughes <sydneyeh@umich.edu>
Date: Sat, 16 Apr 2022 11:55:07 -0400
Subject: [PATCH 6/7] changes to v1.5.0.rst and eliminate for loop in ops.py

---
 doc/source/whatsnew/v1.5.0.rst            |    5 +-
 pandas/tests/groupby/test_groupby_last.py | 1385 ---------------------
 2 files changed, 2 insertions(+), 1388 deletions(-)
 delete mode 100644 pandas/tests/groupby/test_groupby_last.py

diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index edb3c823b2127..e8a05b8abd477 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -453,8 +453,7 @@ Performance improvements
 .. _whatsnew_150.bug_fixes:
 
 Bug fixes
-^^^^^^^^^
-- Bug in :func:`gropuby.last()` that caused numpy arrays ordered with last with pd.NA to have dytype:Int64 type rather than dtype:Bool (:issue:`46409`)
+- Bug in :func:`groupby.last()` that caused numpy arrays ordered with last with pd.NA to have dytype:Int64 type rather than dtype:Bool (:issue:`46409`)
 
 Categorical
 ^^^^^^^^^^^
@@ -474,7 +473,7 @@ Datetimelike
 
 Timedelta
 ^^^^^^^^^
-- Bug FIXED in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
+- Bug in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
 - 
 
 Time Zones
diff --git a/pandas/tests/groupby/test_groupby_last.py b/pandas/tests/groupby/test_groupby_last.py
deleted file mode 100644
index b582dbc7dfa76..0000000000000
--- a/pandas/tests/groupby/test_groupby_last.py
+++ /dev/null
@@ -1,1385 +0,0 @@
-import pandas as pd
-
-
-def test_group_last_use_ops_0():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, True, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype() 
-
-
-def test_group_last_use_ops_1():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, True, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_2():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, True, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_3():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, False, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_4():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, False, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_5():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, False, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_6():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, True, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_6():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, False, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_7():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_8():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-def test_group_last_use_ops_9():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_10():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_11():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_12():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_13():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_14():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_15():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_16():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_17():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_18():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_19():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_20():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_21():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_22():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_23():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_24():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-
-def test_group_last_use_ops_26():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, pd.NA, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_27():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, pd.NA, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_28():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_29():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_30():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, True, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_31():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, False, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_32():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, pd.NA, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_33():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, pd.NA, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_34():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_35():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_36():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, pd.NA, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_37():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, pd.NA, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_38():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, pd.NA, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_39():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, pd.NA, pd.NA, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_40():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, pd.NA, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_41():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, pd.NA, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_42():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, pd.NA, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_43():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, pd.NA, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_44():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, True, pd.NA, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_45():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, False, pd.NA, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_46():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, True, True, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_47():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, False, False, pd.NA]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_48():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, pd.NA, pd.NA, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_49():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, pd.NA, pd.NA, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_50():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, pd.NA, pd.NA, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_51():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, pd.NA, pd.NA, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_52():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, pd.NA, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_53():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, pd.NA, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_55():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, pd.NA, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_56():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, pd.NA, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_57():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_58():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, pd.NA, pd.NA, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_59():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, pd.NA, pd.NA, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_60():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, pd.NA, pd.NA, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_61():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, pd.NA, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_62():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, pd.NA, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_63():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_64():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_65():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_66():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, True, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_67():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, False, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_68():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, True, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_69():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, False, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_70():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, False, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_71():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_72():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, False, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_73():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, True, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_74():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, True, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_75():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_76():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, False, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_77():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, False, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_78():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_79():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_80():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_81():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [True, pd.NA, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_82():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [False, pd.NA, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_83():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_84():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, True, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_85():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, False, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_86():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4],
-            'test': [pd.NA, pd.NA, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_87():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_88():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_89():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_90():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_91():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [True, pd.NA, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_92():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [False, pd.NA, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_93():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_94():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5],
-            'test': [pd.NA, pd.NA, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_95():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_96():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_97():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_98():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_99():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [True, pd.NA, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_100():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [False, pd.NA, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-def test_group_last_use_ops_101():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_102():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6],
-            'test': [pd.NA, pd.NA, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_103():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, True, True, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_104():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, False, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_105():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, True, True, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_106():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, False, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_107():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [True, pd.NA, True, True, True, True, True, True, True, True, True, True,
-                     True, True, True, True, True, True, True, True]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_108():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [False, pd.NA, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-
-
-def test_group_last_use_ops_109():
-    df = pd.DataFrame(
-        {
-            'id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-            'test': [pd.NA, pd.NA, False, False, False, False, False, False, False, False,
-                     False, False, False, False, False, False, False, False, False, False]
-        }
-    ).convert_dtypes()
-    grouped = df.groupby('id')
-    bad = grouped.last()
-    
-    assert bad.test.dtype == pd.BooleanDtype()
-

From 13117f303e6b32c8401cff103272c218db1255a3 Mon Sep 17 00:00:00 2001
From: Sydney Hughes <sydneyeh@umich.edu>
Date: Sat, 16 Apr 2022 16:17:36 +0000
Subject: [PATCH 7/7] Fixes from pre-commit [automated commit]

---
 doc/source/whatsnew/v1.5.0.rst              | 2 +-
 doc/source/whatsnew/v1.5.0_BACKUP_28826.rst | 2 +-
 doc/source/whatsnew/v1.5.0_BASE_28826.rst   | 2 +-
 doc/source/whatsnew/v1.5.0_LOCAL_28826.rst  | 2 +-
 pandas/core/groupby/ops.py                  | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 5ad40fe6bb95b..fc3b01d35861b 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -479,7 +479,7 @@ Timedelta
 ^^^^^^^^^
 <<<<<<< HEAD
 - Bug in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
-- 
+-
 =======
 - Bug FIXED in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
 -
diff --git a/doc/source/whatsnew/v1.5.0_BACKUP_28826.rst b/doc/source/whatsnew/v1.5.0_BACKUP_28826.rst
index 5ad40fe6bb95b..fc3b01d35861b 100644
--- a/doc/source/whatsnew/v1.5.0_BACKUP_28826.rst
+++ b/doc/source/whatsnew/v1.5.0_BACKUP_28826.rst
@@ -479,7 +479,7 @@ Timedelta
 ^^^^^^^^^
 <<<<<<< HEAD
 - Bug in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
-- 
+-
 =======
 - Bug FIXED in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
 -
diff --git a/doc/source/whatsnew/v1.5.0_BASE_28826.rst b/doc/source/whatsnew/v1.5.0_BASE_28826.rst
index 2ec142fe7e423..72490fc67bcc0 100644
--- a/doc/source/whatsnew/v1.5.0_BASE_28826.rst
+++ b/doc/source/whatsnew/v1.5.0_BASE_28826.rst
@@ -474,7 +474,7 @@ Datetimelike
 Timedelta
 ^^^^^^^^^
 - Bug FIXED in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
-- 
+-
 
 Time Zones
 ^^^^^^^^^^
diff --git a/doc/source/whatsnew/v1.5.0_LOCAL_28826.rst b/doc/source/whatsnew/v1.5.0_LOCAL_28826.rst
index e8a05b8abd477..fe655c1aa4bc6 100644
--- a/doc/source/whatsnew/v1.5.0_LOCAL_28826.rst
+++ b/doc/source/whatsnew/v1.5.0_LOCAL_28826.rst
@@ -474,7 +474,7 @@ Datetimelike
 Timedelta
 ^^^^^^^^^
 - Bug in :func:`astype_nansafe` astype("timedelta64[ns]") fails when np.nan is included (:issue:`45798`)
-- 
+-
 
 Time Zones
 ^^^^^^^^^^
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 9a2f5d94eeb95..42364bebfd659 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -571,7 +571,7 @@ def _call_cython_op(
                     **kwargs,
                 )
 
-        if self.how == 'last' and dtype == bool:
+        if self.how == "last" and dtype == bool:
             result = values
 
         if self.kind == "aggregate":