smarter x or y behaviour

Author: nicolaskruchten

packages/python/plotly/plotly/express/_chart_types.py

@@ -25,6 +25,7 @@ def scatter(
     animation_group=None,
     category_orders={},
     labels={},
+    orientation=None,
     color_discrete_sequence=None,
     color_discrete_map={},
     color_continuous_scale=None,
@@ -192,6 +193,7 @@ def line(
     animation_group=None,
     category_orders={},
     labels={},
+    orientation=None,
     color_discrete_sequence=None,
     color_discrete_map={},
     line_dash_sequence=None,

packages/python/plotly/plotly/express/_core.py

@@ -930,12 +930,10 @@ def build_dataframe(args, constructor):
 
     df_input = args["data_frame"]
 
-    wide_mode = (
-        df_provided
-        and args.get("x", None) is None
-        and args.get("y", None) is None
-        and constructor in [go.Scatter, go.Bar, go.Violin, go.Box, go.Histogram]
-    )
+    no_x = args.get("x", None) is None
+    no_y = args.get("y", None) is None
+    wideable = [go.Scatter, go.Bar, go.Violin, go.Box, go.Histogram]
+    wide_mode = df_provided and no_x and no_y and constructor in wideable
     wide_id_vars = set()
 
     if wide_mode:
@@ -944,6 +942,17 @@ def build_dataframe(args, constructor):
     else:
         df_output = pd.DataFrame()
 
+    missing_bar_dim = None
+    if constructor in [go.Scatter, go.Bar] and (no_x != no_y):
+        for ax in ["x", "y"]:
+            if args.get(ax, None) is None:
+                args[ax] = df_input.index if df_provided else Range()
+                if constructor == go.Scatter:
+                    if args["orientation"] is None:
+                        args["orientation"] = "v" if ax == "x" else "h"
+                if constructor == go.Bar:
+                    missing_bar_dim = ax
+
     # Initialize set of column names
     # These are reserved names
     if df_provided:
@@ -1088,12 +1097,27 @@ def build_dataframe(args, constructor):
                 args[field_name][i] = str(col_name)
             wide_id_vars.add(str(col_name))
 
-    for col_name in constants:
-        df_output[col_name] = constants[col_name]
+    if missing_bar_dim and constructor == go.Bar:
+        # now that we've populated df_output, we check to see if the non-missing
+        # dimensio is categorical: if so, then setting the missing dimension to a
+        # constant 1 is a less-insane thing to do than setting it to the index by
+        # default and we let the normal auto-orientation-code do its thing later
+        other_dim = "x" if missing_bar_dim == "y" else "y"
+        if not _is_continuous(df_output, args[other_dim]):
+            args[missing_bar_dim] = missing_bar_dim
+            constants[missing_bar_dim] = 1
+        else:
+            # on the other hand, if the non-missing dimension is continuous, then we
+            # can use this information to override the normal auto-orientation code
+            if args["orientation"] is None:
+                args["orientation"] = "v" if missing_bar_dim == "x" else "h"
 
     for col_name in ranges:
         df_output[col_name] = range(len(df_output))
 
+    for col_name in constants:
+        df_output[col_name] = constants[col_name]
+
     if wide_mode:
         # TODO multi-level index
         # TODO multi-level columns
@@ -1105,9 +1129,8 @@ def build_dataframe(args, constructor):
             id_vars=wide_id_vars, var_name=var_name, value_name="_value_"
         )
         df_output[var_name] = df_output[var_name].astype(str)
-        orient_v = "v" == (args.get("orientation", None) or "v")
-        if "orientation" in args:
-            args["orientation"] = "v" if orient_v else "h"
+        args["orientation"] = args.get("orientation", None) or "v"
+        orient_v = args["orientation"] == "v"
         if constructor in [go.Scatter, go.Bar]:
             args["x" if orient_v else "y"] = index_name
             args["y" if orient_v else "x"] = "_value_"

packages/python/plotly/plotly/tests/test_core/test_px/test_px_input.py

@@ -393,33 +393,32 @@ def test_auto_orient():
     categorical = ["a", "a", "b", "b"]
     numerical = [1, 2, 3, 4]
 
-    pattern_x_or_y = [
-        (numerical, None, "h"),  # auto
-        (categorical, None, "h"),  # auto
-        (None, categorical, "v"),  # auto/default
-        (None, numerical, "v"),  # auto/default
-    ]
+    auto_orientable = [px.scatter, px.line, px.area, px.violin, px.box, px.strip]
+    auto_orientable += [px.bar, px.funnel, px.histogram]
 
     pattern_x_and_y = [
         (numerical, categorical, "h"),  # auto
         (categorical, numerical, "v"),  # auto/default
         (categorical, categorical, "v"),  # default
         (numerical, numerical, "v"),  # default
     ]
-
-    for fn in [px.violin, px.box, px.strip, px.bar, px.funnel]:
-        for x, y, result in pattern_x_or_y:
+    for fn in auto_orientable:
+        for x, y, result in pattern_x_and_y:
             assert fn(x=x, y=y).data[0].orientation == result
 
-    # these ones are the opposite of the ones above in the "or" cases
-    for fn in [px.area, px.histogram]:
-        for x, y, result in pattern_x_or_y:
-            assert fn(x=x, y=y).data[0].orientation != result
+    pattern_x_or_y = [
+        (numerical, None, "h"),  # auto
+        (categorical, None, "h"),  # auto
+        (None, categorical, "v"),  # auto/default
+        (None, numerical, "v"),  # auto/default
+    ]
 
-    # all behave the same for the "and" cases
-    for fn in [px.violin, px.box, px.strip, px.bar, px.funnel, px.area, px.histogram]:
-        for x, y, result in pattern_x_and_y:
-            assert fn(x=x, y=y).data[0].orientation == result
+    for fn in auto_orientable:
+        for x, y, result in pattern_x_or_y:
+            if fn == px.histogram or (fn == px.bar and categorical in [x, y]):
+                assert fn(x=x, y=y).data[0].orientation != result
+            else:
+                assert fn(x=x, y=y).data[0].orientation == result
 
     assert px.histogram(x=numerical, nbins=5).data[0].nbinsx == 5
     assert px.histogram(y=numerical, nbins=5).data[0].nbinsy == 5
@@ -465,3 +464,69 @@ def test_auto_boxlike_overlay():
     for fn, mode in fn_and_mode:
         for x, y, color, result in pattern:
             assert fn(df, x=x, y=y, color=color).layout[mode] == result
+
+
+def test_x_or_y():
+    categorical = ["a", "a", "b", "b"]
+    numerical = [1, 2, 3, 4]
+    constant = [1, 1, 1, 1]
+    range_4 = [0, 1, 2, 3]
+    index = [11, 12, 13, 14]
+    numerical_df = pd.DataFrame(dict(col=numerical), index=index)
+    categorical_df = pd.DataFrame(dict(col=categorical), index=index)
+    scatter_like = [px.scatter, px.line, px.area]
+    bar_like = [px.bar]
+
+    for fn in scatter_like + bar_like:
+        fig = fn(x=numerical)
+        assert list(fig.data[0].x) == numerical
+        assert list(fig.data[0].y) == range_4
+        assert fig.data[0].orientation == "h"
+        fig = fn(y=numerical)
+        assert list(fig.data[0].x) == range_4
+        assert list(fig.data[0].y) == numerical
+        assert fig.data[0].orientation == "v"
+        fig = fn(numerical_df, x="col")
+        assert list(fig.data[0].x) == numerical
+        assert list(fig.data[0].y) == index
+        assert fig.data[0].orientation == "h"
+        fig = fn(numerical_df, y="col")
+        assert list(fig.data[0].x) == index
+        assert list(fig.data[0].y) == numerical
+        assert fig.data[0].orientation == "v"
+
+    for fn in scatter_like:
+        fig = fn(x=categorical)
+        assert list(fig.data[0].x) == categorical
+        assert list(fig.data[0].y) == range_4
+        assert fig.data[0].orientation == "h"
+        fig = fn(y=categorical)
+        assert list(fig.data[0].x) == range_4
+        assert list(fig.data[0].y) == categorical
+        assert fig.data[0].orientation == "v"
+        fig = fn(categorical_df, x="col")
+        assert list(fig.data[0].x) == categorical
+        assert list(fig.data[0].y) == index
+        assert fig.data[0].orientation == "h"
+        fig = fn(categorical_df, y="col")
+        assert list(fig.data[0].x) == index
+        assert list(fig.data[0].y) == categorical
+        assert fig.data[0].orientation == "v"
+
+    for fn in bar_like:
+        fig = fn(x=categorical)
+        assert list(fig.data[0].x) == categorical
+        assert list(fig.data[0].y) == constant
+        assert fig.data[0].orientation == "v"
+        fig = fn(y=categorical)
+        assert list(fig.data[0].x) == constant
+        assert list(fig.data[0].y) == categorical
+        assert fig.data[0].orientation == "h"
+        fig = fn(categorical_df, x="col")
+        assert list(fig.data[0].x) == categorical
+        assert list(fig.data[0].y) == constant
+        assert fig.data[0].orientation == "v"
+        fig = fn(categorical_df, y="col")
+        assert list(fig.data[0].x) == constant
+        assert list(fig.data[0].y) == categorical
+        assert fig.data[0].orientation == "h"