def test_pivot_longer_rename_not_rangeindex(self): """ Test if pivot_longer makes a RangeIndex if current index is not a RangeIndex and preserves the orignal as a new column "index_to" """ wide = DataFrame( { "One": {"A": 1.0, "B": 2.0, "C": 3.0}, "Two": {"A": 1.0, "B": 2.0, "C": 3.0}, } ) long = gr.tran_pivot_longer( wide, columns=("One","Two"), index_to="idx", names_to="columns", values_to="values" ) expected = DataFrame( { "idx": ["A", "B", "C", "A", "B", "C"], "columns": ["One", "One", "One", "Two", "Two", "Two"], "values": [1.0, 2.0, 3.0, 1.0, 2.0, 3.0], } ) assert_frame_equal(long, expected)
def test_pivot_longer_names_sep_and_index_to(self): """ Test if pivot_longer works with names_sep and index_to arguments together """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, index_to="idx", names_sep="_", columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to=("property", "angle"), values_to="val" ) long_index = list(long["idx"]) mod = max(long_index) single_index = list(range(0, mod)) check = ["property","angle"] col_check = [x for x in long.columns.values if x in check] result = False if single_index == long_index[0:mod]: if check == col_check: result = True self.assertTrue(result)
def test_pivot_wider_representation_index(self): """ Test if pivot_wider can handle duplicate entries if a representation index is present """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, index_to = "idx", columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to="var", values_to="val" ) wide = gr.tran_pivot_wider( long, names_from="var", values_from="val" ) expected = gr.df_make( idx=[0,1,2,3,4,5,6,7,8], thick=[0.022,0.022,0.032,0.032,0.064,0.064,0.081,0.081,0.081], alloy=[" al_24st"," al_24st"," al_24st"," al_24st"," al_24st", " al_24st"," al_24st"," al_24st"," al_24st"], E_00=[10600.000,10600.000,10400.000,10300.000,10500.000,10700.000, 10000.000,10100.000,10000.000], E_45=[10700.000,10500.000,10400.000,10500.000,10400.000,10500.00, 10000.000,9900.000,-1.0], E_90=[10500.000,10700.000,10300.000,10400.000,10400.000,10500.000, 9900.000,10000.000,9900.000], mu_00=[0.321,0.323,0.329,0.319,0.323,0.328,0.315,0.312,0.311], mu_45=[0.329,0.331,0.318,0.326,0.331,0.328,0.320,0.312,-1.000], mu_90=[0.310,0.323,0.322,0.330,0.327,0.320,0.314,0.316,0.314] ) assert_frame_equal(wide, expected)
def test_pivot_longer_dot_value_and_names_sep(self): """ Test pivot_longer when it receives the .value and names_sep """ DF = gr.Intention() wide = gr.df_make(x=range(0, 6)) wide = gr.tran_mutate( wide, y_Trend=DF.x**2, y_Variability=random.normal(size=6), y_Mixed=DF.x**2 + random.normal(size=6), ) long = gr.tran_pivot_longer( wide, columns=["y_Trend", "y_Variability", "y_Mixed"], names_to=(".value", "type"), names_sep="_" ) check = ["x", "type", "y"] col_check = [x for x in long.columns.values if x in check] result = False if set(col_check) == set(check): result = True self.assertTrue(result)
def test_pivot_longer_dot_value_in_the_middle(self): """ Test pivot_longer when it receives the .value input in between at least 2 other inputs in 'names_to' """ stang = data.df_stang_wide # rename columns for this test for i in stang.columns.values: stang.rename(columns={i: ('NA_'+i)},inplace=True) stang.rename(columns={'NA_thick': 'thick'},inplace=True) stang.rename(columns={'NA_alloy': 'alloy'},inplace=True) long = gr.tran_pivot_longer( stang, names_sep="_", columns=["NA_E_00","NA_mu_00","NA_E_45","NA_mu_45","NA_E_90","NA_mu_90"], names_to=("null", ".value", "angle"), values_to="val" ) columns = list(long.columns.values) null_count = columns.count("null") E_count = columns.count("E") mu_count = columns.count("mu") result = False if E_count > 0 and mu_count > 0 and null_count > 0: result = True self.assertTrue(result) # undo column renaming for future tests null = 'NA_' for i in stang.columns.values: if null in i: stang.rename(columns={i: i.lstrip(null)},inplace=True)
def test_pivot_longer_matches(self): """ Test if pivot_longer is compatible with gr.matches as columns input """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, columns = gr.matches("\\d+"), names_to="var", values_to="val" ) expected = gr.tran_pivot_longer( stang, columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to="var", values_to="val" ) assert_frame_equal(long, expected)
def test_pivot_longer_select(self): """ Test if pivot_longer is compatible with gr.tran_select or any input of a DataFrame instead as 'columns' argument """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, columns=(gr.tran_select(stang,gr.matches("\\d+"))), names_to="var", values_to="val" ) expected = gr.tran_pivot_longer( stang, columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to="var", values_to="val" ) assert_frame_equal(long, expected)
def test_pivot_longer_matches_error(self): """ Test if selection helper retrieves no matches """ with self.assertRaises(ValueError): stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, columns = gr.matches("0123"), names_to="var", values_to="val" )
def test_pivot_longer_names_sep_names_to_is_1(self): """ Test if pivot_longer raises an error for only giving one value to names_to and calling names_sep """ with self.assertRaises(TypeError): stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, names_sep="_", columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to="property", values_to="val" )
def test_pivot_longer_names_sep_and_pattern(self): """ Test if pivot_longer raises a ValueError if both names_sep and names_pattern are called """ with self.assertRaises(ValueError): stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, names_pattern="(E|mu)_(\\d+)", names_sep="_", columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to=("property", "angle"), values_to="val" )
def test_pivot_longer(self): """ Test basic functionality of pivot_longer """ wide = gr.df_make(One=[1,2,3], Two=[4,5,6]) long = gr.tran_pivot_longer( wide, columns=("One","Two"), names_to="columns", values_to="values" ) expected = gr.df_make( columns=["One","One","One","Two","Two","Two"], values=[1,2,3,4,5,6] ) assert_frame_equal(long, expected)
def test_pivot_wider_duplicate_entries(self): """ Test if pivot_wider raise an error for duplicate entries """ with self.assertRaises(ValueError): stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to="var", values_to="val" ) wide = gr.tran_pivot_wider( long, names_from="var", values_from="val" )
def test_pivot_longer_dot_value(self): """ Test pivot_longer when it receives the .value input for names_to """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to=".value", values_to="val" ) check = ["E_00","mu_00","E_45","mu_45","E_90","mu_90"] col_check = [x for x in long.columns.values if x in check] result = False if set(col_check) == set(check): result = True self.assertTrue(result)
def test_pivot_longer_names_sep_position_thrice(self): """ Test if pivot_longer works with names_sep argument being a position """ wide = gr.df_make(A_1_hello=[1,2,3], B_2_bye=[4,5,6]) long = gr.tran_pivot_longer( wide, names_sep=[1, 3], columns=["A_1_hello","B_2_bye"], names_to=("letter","num","saying"), values_to="val" ) names_to = ["letter","num","saying"] names_to_check = [x for x in long.columns.values if x in names_to] result = False if names_to == names_to_check: result = True self.assertTrue(result)
def test_pivot_longer_names_sep_position(self): """ Test if pivot_longer works with names_sep argument being a position """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, names_sep=[-3], columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to=("property", "angle"), values_to="val" ) names_to = ["property","angle"] names_to_check = [x for x in long.columns.values if x in names_to] result = False if names_to == names_to_check: result = True self.assertTrue(result)
def test_pivot_longer_no_representation_index(self): """ Test if pivot_longer does not produce a representation index for nx2 DataFrame that has no index_to call """ wide = gr.df_make(A=[1,2,3], B=[4,5,6]) long = gr.tran_pivot_longer( wide, columns=("A", "B"), names_to="var", values_to="value" ) expected = DataFrame( { "var": ["A","A","A","B","B","B"], "value": [1,2,3,4,5,6] } ) assert_frame_equal(long, expected)
def test_pivot_longer_names_sep_thrice(self): """ Test if pivot_longer properly works with names_sep having to split columns into 3 or more """ wide = gr.df_make(A_1_hello=[1,2,3], B_2_bye=[4,5,6]) long = gr.tran_pivot_longer( wide, names_sep="_", columns=["A_1_hello","B_2_bye"], names_to=("letter","num","saying"), values_to="val" ) names_to = ["letter","num","saying"] names_to_check = [x for x in long.columns.values if x in names_to] result = False if names_to == names_to_check: result = True self.assertTrue(result)
def test_pivot_longer_names_pattern(self): """ Test if pivot_longer properly works with names_pattern """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, names_pattern="(E|mu)_(\\d+)", columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to=("property", "angle"), values_to="val" ) names_to = ["property","angle"] names_to_check = [x for x in long.columns.values if x in names_to] result = False if names_to == names_to_check: result = True self.assertTrue(result)
def test_pivot_longer_names_sep_multiple_seps(self): """ Test if pivot_longer properly works with names_sep having column names with varying amount of seps """ wide = gr.df_make(A_1_hello=[1,2,3], B_2=[4,5,6]) long = gr.tran_pivot_longer( wide, names_sep="_", columns=["A_1_hello","B_2"], names_to=("letter","num","saying"), values_to="val" ) names_to = ["letter","num","saying"] names_to_check = [x for x in long.columns.values if x in names_to] result = False if names_to == names_to_check: result = True self.assertTrue(result)
def test_pivot_longer_dot_value_and_name(self): """ Test pivot_longer when it receives the .value and another input for names_to """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, names_sep="_", columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to=(".value", "angle"), values_to="val" ) columns = list(long.columns.values) E_count = columns.count("E") mu_count = columns.count("mu") result = False if E_count > 0 and mu_count > 0: result = True self.assertTrue(result)
def test_pivot_wider_NaN_entries(self): """ Test if pivot_wider returns a table with NaN values for unspecified entries that have no represenational index """ original = gr.df_make(A=[1,2,3], B=[4,5,6]) long = gr.tran_pivot_longer( original, columns=("A", "B"), names_to="var", values_to="value" ) wide = gr.tran_pivot_wider( long, names_from="var", values_from="value" ) expected = gr.df_make( A=[1,2,3,NaN,NaN,NaN], B=[NaN,NaN,NaN,4,5,6] ) assert_frame_equal(wide, expected)
def test_pivot_longer_rep_index_groups(self): """ Test if pivot_longer adds a representation index correctly when there is multiple groupings of observations """ stang = data.df_stang_wide long = gr.tran_pivot_longer( stang, index_to = "idx", columns=["E_00","mu_00","E_45","mu_45","E_90","mu_90"], names_to="var", values_to="val" ) long_index = list(long["idx"]) mod = max(long_index) single_index = list(range(0, mod)) result = False if single_index == long_index[0:mod]: result = True self.assertTrue(result)