get rid of nested dictionary

Author: samuel.oranyeli

janitor/functions/summarize.py

@@ -115,17 +115,8 @@ def summarize(
                 check(
                     f"func for {col} in argument {num}",
                     func,
-                    [str, callable, dict],
+                    [str, callable],
                 )
-                if isinstance(func, dict):
-                    for _, funcn in func.items():
-                        check(
-                            f"func in nested dictionary for "
-                            f"{col} in argument {num}",
-                            funcn,
-                            [str, callable],
-                        )
-
         else:
             if len(arg) < 2:
                 raise ValueError(
@@ -171,24 +162,12 @@ def summarize(
     for arg in args:
         if isinstance(arg, dict):
             for col, func in arg.items():
-                if by_is_true:
-                    val = grp[col]
-                else:
-                    val = df[col]
-                if isinstance(func, dict):
-                    for key, funcn in func.items():
-                        try:
-                            outcome = val.agg(funcn)
-                        except (ValueError, AttributeError):
-                            outcome = funcn(val)
-                        aggs[key] = outcome
-                else:
-                    try:
-                        outcome = val.agg(func)
-                    except (ValueError, AttributeError):
-                        outcome = func(val)
-                    aggs[col] = outcome
-
+                val = grp if by_is_true else df
+                try:
+                    outcome = val.agg(func)
+                except (ValueError, AttributeError):
+                    outcome = func(val)
+                aggs[col] = outcome
         else:
             columns, func, names = SD(*arg)
             columns = _select_index([columns], df, axis="columns")
@@ -221,10 +200,7 @@ def summarize(
             counts = None
             func_names = tuple(zip(func_names, func))
             for col in columns:
-                if by_is_true:
-                    val = grp[col]
-                else:
-                    val = df[col]
+                val = grp[col] if by_is_true else df[col]
                 for name, funcn in func_names:
                     if names:
                         name = names.format(_col=col, _fn=name)

tests/functions/test_summarize.py

@@ -26,30 +26,9 @@ def test_dict_args_val_error(dataframe):
         dataframe.summarize({"a": 1})
 
 
-@pytest.mark.functions
-def test_dict_nested_error(dataframe):
-    """
-    Raise if func in nested dict
-    is a wrong type
-    """
-    with pytest.raises(
-        TypeError, match="func in nested dictionary for a in argument 0.+"
-    ):
-        dataframe.summarize({"a": {"b": 1}})
-
-
 func = lambda grp: grp.Revenue.sum() / grp.Quantity.sum()  # noqa: E731
 
 
-@pytest.mark.functions
-def test_nested_dict_agg_error(dataframe):
-    """
-    Raise if func triggers an attributeerror/valueerror
-    """
-    with pytest.raises(AttributeError):
-        dataframe.summarize({"a": {"b": func}})
-
-
 @pytest.mark.functions
 def test_dict_agg_error(dataframe):
     """
@@ -115,7 +94,12 @@ def test_tuple_func_seq_error(dataframe):
         dataframe.summarize(("a", [np.sum, 1], "name"))
 
 
-args = [{"a": "sum"}, ("a", "sum"), ("a", np.sum), {"a": np.sum}]
+args = [
+    {"a": lambda df: df.a.sum()},
+    ("a", "sum"),
+    ("a", np.sum),
+    {"a": lambda f: np.sum(f.a)},
+]
 
 
 @pytest.mark.parametrize("test_input", args)
@@ -127,54 +111,6 @@ def test_args_various(dataframe, test_input):
     assert_frame_equal(expected, actual)
 
 
-args = [
-    ({"a": "sum"}, "decorated-elephant"),
-    ({"a": np.sum}, "decorated-elephant"),
-    (("a", "sum"), "decorated-elephant"),
-]
-
-
-@pytest.mark.parametrize("test_input,by", args)
-@pytest.mark.functions
-def test_args_various_grouped(dataframe, test_input, by):
-    """Test output for various arguments"""
-    expected = dataframe.groupby("decorated-elephant").agg({"a": "sum"})
-    actual = dataframe.summarize(test_input, by=by)
-    assert_frame_equal(expected, actual)
-
-
-@pytest.mark.functions
-def test_dict_nested(dataframe):
-    """Test output for dict"""
-    expected = (
-        dataframe.agg({"a": ["sum"]})
-        .rename(columns={"a": "a_sum"})
-        .reset_index(drop=True)
-    )
-    actual = dataframe.summarize({"a": {"a_sum": "sum"}})
-    assert_frame_equal(expected, actual)
-
-
-@pytest.mark.functions
-def test_dict_nested_grouped_str(dataframe):
-    """Test output for dict on a groupby"""
-    expected = dataframe.groupby("decorated-elephant").agg(a_sum=("a", "sum"))
-    actual = dataframe.summarize(
-        {"a": {"a_sum": "sum"}}, by="decorated-elephant"
-    )
-    assert_frame_equal(expected, actual)
-
-
-@pytest.mark.functions
-def test_dict_nested_grouped_callable(dataframe):
-    """Test output for dict on a groupby"""
-    expected = dataframe.groupby("decorated-elephant").agg(a_sum=("a", "sum"))
-    actual = dataframe.summarize(
-        {"a": {"a_sum": np.sum}}, by={"by": "decorated-elephant"}
-    )
-    assert_frame_equal(expected, actual)
-
-
 args = [("a", "sum", "{_col}_{_fn}"), ("a", np.sum, "{_col}_{_fn}")]
 
 
@@ -231,7 +167,7 @@ def test_tuple_func_list_grouped_dupes(dataframe):
     grp = dataframe.groupby("decorated-elephant")
     expected = grp.agg(a_sum0=("a", "sum"), a_sum1=("a", "sum"))
     actual = dataframe.summarize(
-        ("a", ["sum", np.sum], "{_col}_{_fn}"), by="decorated-elephant"
+        ("a", ["sum", np.sum], "{_col}_{_fn}"), by={"by": "decorated-elephant"}
     )
     assert_frame_equal(expected, actual)