Lazy Streaming of Tabs

lux/_config/config.py

@@ -32,6 +32,8 @@ def __init__(self):
         self._pandas_fallback = True
         self._interestingness_fallback = True
         self.heatmap_bin_size = 40
+        self._streaming = True
+
         #####################################
         #### Optimization Configurations ####
         #####################################

lux/action/correlation.py

@@ -60,10 +60,6 @@ def correlation(ldf: LuxDataFrame, ignore_transpose: bool = True):
             {examples}. The visualizations are ranked from most to least linearly correlated based on \
                 their Pearson’s correlation score.",
     }
-    ignore_rec_flag = False
-    # Doesn't make sense to compute correlation if less than 4 data values
-    if len(ldf) < 5:
-        ignore_rec_flag = True
     # Then use the data populated in the vis list to compute score
     for vis in vlist:
         measures = vis.get_attr_by_data_model("measure")
@@ -81,9 +77,6 @@ def correlation(ldf: LuxDataFrame, ignore_transpose: bool = True):
             vis.score = interestingness(vis, ldf)
         else:
             vis.score = -1
-    if ignore_rec_flag:
-        recommendation["collection"] = []
-        return recommendation
     vlist.sort()
     vlist = vlist.showK()
     recommendation["collection"] = vlist

lux/action/custom.py

@@ -45,36 +45,67 @@ def custom(ldf):
     lux.config.executor.execute(vlist, ldf)
     for vis in vlist:
         vis.score = interestingness(vis, ldf)
-    # ldf.clear_intent()
     vlist.sort(remove_invalid=True)
     return recommendation
 
 
-def custom_actions(ldf):
+def custom_action(ldf, action):
     """
-    Generates user-defined vis based on globally defined actions.
+    Computing initial custom_action for lazy streaming of the rest of the actions
 
     Parameters
     ----------
     ldf : lux.core.frame
         LuxDataFrame with underspecified intent.
 
+    action: action_name as string
+        e.g "Correlation"
+
     Returns
     -------
-    recommendations : Dict[str,obj]
-        object with a collection of visualizations that were previously registered.
+    One recommendation
+    """
+    recommendation = None
+    display_condition = lux.config.actions[action].display_condition
+    if display_condition is None or (display_condition is not None and display_condition(ldf)):
+        args = lux.config.actions[action].args
+        if args:
+            recommendation = lux.config.actions[action].action(ldf, args)
+        else:
+            recommendation = lux.config.actions[action].action(ldf)
+    return recommendation
+
+
+def filter_keys(ldf, loading_bar=None):
     """
-    if len(lux.config.actions) > 0 and (len(ldf) > 0 or lux.config.executor.name != "PandasExecutor"):
-        recommendations = []
+    Filters out actions before beginning computations so we know which tabs to display.
+    Logic to filter out actions in lux/action/default.py
+    """
+
+    keys = []
+    data_types = set(ldf._data_type.values())
+    progress = 0
+    if loading_bar is not None:
+        loading_bar.max = len(lux.config.actions.keys())
+    if len(ldf) > 0 or lux.config.executor.name != "PandasExecutor":
         for action_name in lux.config.actions.keys():
             display_condition = lux.config.actions[action_name].display_condition
             if display_condition is None or (display_condition is not None and display_condition(ldf)):
-                args = lux.config.actions[action_name].args
-                if args:
-                    recommendation = lux.config.actions[action_name].action(ldf, args)
-                else:
-                    recommendation = lux.config.actions[action_name].action(ldf)
-                recommendations.append(recommendation)
-        return recommendations
-    else:
-        return []
+                if lux.config.actions[action_name].args:
+                    if not lux.config.actions[action_name].args[0] in data_types:
+                        continue
+                keys.append(action_name)
+            progress += 1
+            if loading_bar is not None:
+                loading_bar.value = progress
+
+    # # Pushing back correlation and geographical actions for performance reasons
+    if "correlation" in keys:
+        keys.pop(keys.index("correlation"))
+        keys.append("correlation")
+
+    if "geographical" in keys:
+        keys.pop(keys.index("geographical"))
+        keys.append("geographical")
+
+    return keys

lux/action/default.py

@@ -1,12 +1,17 @@
+import lux
+from lux.action.custom import custom
+from lux.action.correlation import correlation
+from lux.action.univariate import univariate
+from lux.action.enhance import enhance
+from lux.action.filter import add_filter
+from lux.action.generalize import generalize
+from lux.action.temporal import temporal, create_temporal_vis
+from lux.utils import utils
+from lux.vis.VisList import VisList
+from lux.interestingness.interestingness import interestingness
+
+
 def register_default_actions():
-    import lux
-    from lux.action.custom import custom
-    from lux.action.correlation import correlation
-    from lux.action.univariate import univariate
-    from lux.action.enhance import enhance
-    from lux.action.filter import add_filter
-    from lux.action.generalize import generalize
-    from lux.action.temporal import temporal
 
     # display conditions for default actions
     no_vis = lambda ldf: (ldf.current_vis is None) or (
@@ -16,14 +21,108 @@ def register_default_actions():
     multiple_current_vis = lambda ldf: ldf.current_vis is not None and len(ldf.current_vis) > 1
 
     # globally register default actions
-    lux.config.register_action("correlation", correlation, no_vis)
-    lux.config.register_action("distribution", univariate, no_vis, "quantitative")
-    lux.config.register_action("occurrence", univariate, no_vis, "nominal")
-    lux.config.register_action("temporal", temporal, no_vis)
+    lux.config.register_action("correlation", correlation, correlation_check)
+    lux.config.register_action("distribution", univariate, distribution_check, "quantitative")
+    lux.config.register_action("occurrence", univariate, occurence_check, "nominal")
+    lux.config.register_action("temporal", temporal, temporal_check)
     lux.config.register_action("geographical", univariate, no_vis, "geographical")
 
-    lux.config.register_action("Enhance", enhance, one_current_vis)
+    lux.config.register_action("Enhance", enhance, enhance_check)
     lux.config.register_action("Filter", add_filter, one_current_vis)
-    lux.config.register_action("Generalize", generalize, one_current_vis)
+    lux.config.register_action("Generalize", generalize, generalize_check)
 
     lux.config.register_action("Custom", custom, multiple_current_vis)
+
+
+def generalize_check(ldf):
+    filters = utils.get_filter_specs(ldf._intent)
+    attributes = list(filter(lambda x: x.value == "" and x.attribute != "Record", ldf._intent))
+    if (len(attributes) <= 1 or len(attributes) > 4) and len(filters) == 0:
+        return False
+    else:
+        return ldf.current_vis is not None and len(ldf.current_vis) == 1
+
+
+def correlation_check(ldf):
+    if len(ldf) < 5:
+        return False
+    else:
+        if (ldf.current_vis is None) or (ldf.current_vis is not None and len(ldf.current_vis) == 0):
+            filter_specs = utils.get_filter_specs(ldf._intent)
+            intent = [
+                lux.Clause("?", data_model="measure"),
+                lux.Clause("?", data_model="measure"),
+            ]
+            intent.extend(filter_specs)
+            vlist = VisList(intent, ldf)
+            if len(vlist) < 1:
+                return False
+            return True
+        else:
+            if len(ldf.columns) == 2:
+                return True
+            return False
+
+
+def occurence_check(ldf):
+    filter_specs = utils.get_filter_specs(ldf._intent)
+    intent = [lux.Clause("?", data_type="nominal")]
+    intent.extend(filter_specs)
+    vlist = VisList(intent, ldf)
+    for vis in vlist:
+        vis.score = interestingness(vis, ldf)
+    vlist.sort()
+
+    if len(vlist) < 1:
+        return False
+    else:
+        return (ldf.current_vis is None) or (ldf.current_vis is not None and len(ldf.current_vis) == 0)
+
+
+def distribution_check(ldf):
+    filter_specs = utils.get_filter_specs(ldf._intent)
+    possible_attributes = [
+        c
+        for c in ldf.columns
+        if ldf.data_type[c] == "quantitative" and ldf.cardinality[c] > 5 and c != "Number of Records"
+    ]
+    intent = [lux.Clause(possible_attributes)]
+    intent.extend(filter_specs)
+    vlist = VisList(intent, ldf)
+    if len(vlist) < 1:
+        return False
+    else:
+        return (ldf.current_vis is None) or (ldf.current_vis is not None and len(ldf.current_vis) == 0)
+
+
+def temporal_check(ldf):
+    # Doesn't make sense to generate a line chart if there is less than 3 datapoints (pre-aggregated)
+    if len(ldf) < 3:
+        return False
+
+    for c in ldf.columns:
+        if ldf.data_type[c] == "temporal":
+            return True
+
+    filter_specs = utils.get_filter_specs(ldf._intent)
+    intent = [lux.Clause("?", data_type="temporal")]
+    intent.extend(filter_specs)
+    vlist = VisList(intent, ldf)
+    for vis in vlist:
+        vis.score = interestingness(vis, ldf)
+    vlist.sort()
+
+    if len(vlist) < 1:
+        return False
+    else:
+        return (ldf.current_vis is None) or (ldf.current_vis is not None and len(ldf.current_vis) == 0)
+
+
+def enhance_check(ldf):
+    filters = utils.get_filter_specs(ldf._intent)
+    intent = ldf._intent.copy()
+    attr_specs = list(filter(lambda x: x.value == "" and x.attribute != "Record", ldf._intent))
+    if len(attr_specs) > 2:
+        return False
+    else:
+        return ldf.current_vis is not None and len(ldf.current_vis) == 1

lux/action/generalize.py

@@ -51,10 +51,6 @@ def generalize(ldf):
         "long_description": f"Remove one aspect of the Current Vis. We can either remove an attribute or filter from {intended_attrs}.",
     }
     # to observe a more general trend
-    # if we do no have enough column attributes or too many, return no vis.
-    if len(attributes) < 1 or len(attributes) > 4:
-        recommendation["collection"] = []
-        return recommendation
     # for each column specification, create a copy of the ldf's vis and remove the column specification
     # then append the vis to the output
     if len(attributes) > 1:

lux/action/temporal.py

@@ -61,10 +61,6 @@ def temporal(ldf):
             + " followed by trends across other timescales (e.g., year, month, week, day)."
         )
 
-    # Doesn't make sense to generate a line chart if there is less than 3 datapoints (pre-aggregated)
-    if len(ldf) < 3:
-        recommendation["collection"] = []
-        return recommendation
     vlist.sort()
     recommendation["collection"] = vlist
     return recommendation

lux/action/univariate.py

@@ -58,9 +58,6 @@ def univariate(ldf, *args):
             "description": "Show univariate histograms of <p class='highlight-descriptor'>quantitative</p>  attributes.",
             "long_description": f"Distribution displays univariate histogram distributions of all quantitative attributes{examples}. Visualizations are ranked from most to least skewed.",
         }
-        # Doesn't make sense to generate a histogram if there is less than 5 datapoints (pre-aggregated)
-        if len(ldf) < 5:
-            ignore_rec_flag = True
     elif data_type_constraint == "nominal":
         possible_attributes = [
             c for c in ldf.columns if ldf.data_type[c] == "nominal" and c != "Number of Records"
@@ -89,6 +86,14 @@ def univariate(ldf, *args):
             "description": "Show choropleth maps of <p class='highlight-descriptor'>geographic</p> attributes",
             "long_description": f"Occurence displays choropleths of averages for some geographic attribute{examples}. Visualizations are ranked by diversity of the geographic attribute.",
         }
+    elif data_type_constraint == "temporal":
+        intent = [lux.Clause("?", data_type="temporal")]
+        intent.extend(filter_specs)
+        recommendation = {
+            "action": "Temporal",
+            "description": "Show trends over <p class='highlight-descriptor'>time-related</p> attributes.",
+            "long_description": "Temporal displays line charts for all attributes related to datetimes in the dataframe.",
+        }
     if ignore_rec_flag:
         recommendation["collection"] = []
         return recommendation