fix load

app.py

@@ -51,6 +51,10 @@ function setDataFrameReadonly() {
 """
 text_functions_df = pd.read_csv("text_functions.tsv", delimiter="\t")
 
+@lru_cache(maxsize=3)
+def duckdb_sql(query: str) -> duckdb.DuckDBPyRelation:
+    return duckdb.sql(query)
+
 def prepare_function(func: str, placeholder: str, column_name: str) -> str:
     if "(" in func:
         prepared_func = func.split("(")
@@ -75,63 +79,94 @@ with gr.Blocks(css=css, js=js) as demo:
             transform_dropdowns += [gr.Dropdown(choices=[None], value=None, container=False, interactive=True, allow_custom_value=True, visible=False) for _ in range(MAX_NUM_COLUMNS - len(transform_dropdowns))]
         dataframe = gr.DataFrame(EMPTY_DF, column_widths=[f"{1/len(EMPTY_DF.columns):.0%}"] * len(EMPTY_DF.columns), interactive=True, elem_classes="readonly-dataframe")
 
-    @demo.load(outputs=dataset_dropdown)
-    def _fetch_datasets(request: gr.Request, oauth_token: gr.OAuthToken | None):
-        api = HfApi(token=oauth_token.token if oauth_token else None)
-        datasets = list(api.list_datasets(limit=3, sort="trendingScore", direction=-1, filter=["format:parquet"]))
-        if oauth_token and (user := api.whoami().get("user")):
-            datasets += list(api.list_datasets(limit=3, sort="trendingScore", direction=-1, filter=["format:parquet"], author=user))
-        dataset = request.query_params.get("dataset") or datasets[0].id
-        return {dataset_dropdown: gr.Dropdown(choices=[dataset.id for dataset in datasets], value=dataset)}
-
-    @dataset_dropdown.change(inputs=dataset_dropdown, outputs=loading_codes_json)
-    def _fetch_read_parquet_loading(dataset: str):
+    def show_subset_dropdown(dataset: str):
         if dataset and "/" not in dataset.strip().strip("/"):
             return []
         resp = requests.get(f"https://datasets-server.huggingface.co/compatible-libraries?dataset={dataset}", timeout=3).json()
-        return ([lib["loading_codes"] for lib in resp.get("libraries", []) if lib["function"] in READ_PARQUET_FUNCTIONS] or [[]])[0] or []
-
-    @loading_codes_json.change(inputs=loading_codes_json, outputs=[subset_dropdown, split_dropdown])
-    def _show_subset_dropdown(loading_codes: list[dict]):
+        loading_codes = ([lib["loading_codes"] for lib in resp.get("libraries", []) if lib["function"] in READ_PARQUET_FUNCTIONS] or [[]])[0] or []
         subsets = [loading_code["config_name"] for loading_code in loading_codes]
         subset = (subsets or [""])[0]
-        splits = ([list(loading_code["arguments"]["splits"]) for loading_code in loading_codes if loading_code["config_name"] == subset] or [[]])[0]
-        split = (splits or [""])[0]
-        return gr.Dropdown(subsets, value=subset, visible=len(subsets) > 1), gr.Dropdown(splits, value=split, visible=len(splits) > 1)
+        return dict(choices=subsets, value=subset, visible=len(subsets) > 1, key=hash(str(loading_codes))), loading_codes
 
-    @subset_dropdown.change(inputs=[loading_codes_json, subset_dropdown], outputs=split_dropdown)
-    def _show_split_dropdown(loading_codes: list[dict], subset: str):
+    def show_split_dropdown(subset: str, loading_codes: list[dict]):
         splits = ([list(loading_code["arguments"]["splits"]) for loading_code in loading_codes if loading_code["config_name"] == subset] or [[]])[0]
         split = (splits or [""])[0]
-        return gr.Dropdown(splits, value=split, visible=len(splits) > 1)
-    
-    @split_dropdown.change(inputs=[dataset_dropdown, subset_dropdown, split_dropdown, loading_codes_json], outputs=input_dataframe)
-    @lru_cache(maxsize=3)
-    def _set_input_dataframe(dataset: str, subset: str, split: str, loading_codes: list[dict]) -> pd.DataFrame:
+        return dict(choices=splits, value=split, visible=len(splits) > 1, key=hash(str(loading_codes) + subset))
+
+    def show_input_dataframe(dataset: str, subset: str, split: str, loading_codes: list[dict]) -> pd.DataFrame:
         pattern = ([loading_code["arguments"]["splits"][split] for loading_code in loading_codes if loading_code["config_name"] == subset] or [None])[0]
         if dataset and subset and split and pattern:
-            df = duckdb.sql(f"SELECT * FROM 'hf://datasets/{dataset}/{pattern}' LIMIT 10").df()
-            return gr.DataFrame(df, column_widths=[f"{1/len(df.columns):.0%}"] * len(df.columns))
+            df = duckdb_sql(f"SELECT * FROM 'hf://datasets/{dataset}/{pattern}' LIMIT 10").df()
+            input_df = df
         else:
-            return gr.DataFrame(EMPTY_DF, column_widths=[f"{1/len(EMPTY_DF.columns):.0%}"] * len(EMPTY_DF.columns))
-    
-    @input_dataframe.change(inputs=input_dataframe, outputs=transform_dropdowns)
-    def _set_transforms(input_df: pd.DataFrame):
-        new_transform_dropdowns = [gr.Dropdown(choices=[column_name] + [prepare_function(text_func, "string", column_name) for text_func in text_functions_df.Name if "string" in text_func], value=column_name, container=False, interactive=True, allow_custom_value=True, visible=True) for column_name in input_df.columns]
-        new_transform_dropdowns += [gr.Dropdown(choices=[None], value=None, container=False, interactive=True, allow_custom_value=True, visible=False) for _ in range(MAX_NUM_COLUMNS - len(new_transform_dropdowns))]
-        return new_transform_dropdowns
+            input_df = EMPTY_DF
+        new_transform_dropdowns = [dict(choices=[column_name] + [prepare_function(text_func, "string", column_name) for text_func in text_functions_df.Name if "string" in text_func], value=column_name, container=False, interactive=True, allow_custom_value=True, visible=True) for column_name in input_df.columns]
+        new_transform_dropdowns += [dict(choices=[None], value=None, container=False, interactive=True, allow_custom_value=True, visible=False) for _ in range(MAX_NUM_COLUMNS - len(new_transform_dropdowns))]
+        return [dict(value=df, column_widths=[f"{1/len(df.columns):.0%}"] * len(df.columns))] + new_transform_dropdowns
     
-    def _set_dataframe(input_df: pd.DataFrame, *transforms: tuple[str], column_index: int):
+    def set_dataframe(input_df: pd.DataFrame, *transforms: tuple[str], column_index: int):
         try:
-            print(f"SELECT {', '.join(transform for transform in transforms if transform)} FROM input_df;")
-            # return input_df
-            return duckdb.sql(f"SELECT {', '.join(transform for transform in transforms if transform)} FROM input_df;")
+            return duckdb.sql(f"SELECT {', '.join(transform for transform in transforms if transform)} FROM input_df;").df()
         except Exception as e:
-            raise gr.Error(f"{type(e).__name__}: {e}")
+            gr.Error(f"{type(e).__name__}: {e}")
+            return input_df
     
     for column_index, transform_dropdown in enumerate(transform_dropdowns):
-        transform_dropdown.change(partial(_set_dataframe, column_index=column_index), inputs=[input_dataframe] + transform_dropdowns, outputs=dataframe)
+        transform_dropdown.select(partial(set_dataframe, column_index=column_index), inputs=[input_dataframe] + transform_dropdowns, outputs=dataframe)
 
+    @demo.load(outputs=[dataset_dropdown, loading_codes_json, subset_dropdown, split_dropdown, input_dataframe, dataframe] + transform_dropdowns)
+    def _fetch_datasets(request: gr.Request, oauth_token: gr.OAuthToken | None):
+        api = HfApi(token=oauth_token.token if oauth_token else None)
+        datasets = list(api.list_datasets(limit=3, sort="trendingScore", direction=-1, filter=["format:parquet"]))
+        if oauth_token and (user := api.whoami().get("name")):
+            datasets += list(api.list_datasets(limit=3, sort="trendingScore", direction=-1, filter=["format:parquet"], author=user))
+        dataset = request.query_params.get("dataset") or datasets[0].id
+        subsets, loading_codes = show_subset_dropdown(dataset)
+        splits = show_split_dropdown(subsets["value"], loading_codes)
+        input_df, *new_transform_dropdowns = show_input_dataframe(dataset, subsets["value"], splits["value"], loading_codes)
+        return {
+            dataset_dropdown: gr.Dropdown(choices=[dataset.id for dataset in datasets], value=dataset),
+            loading_codes_json: loading_codes,
+            subset_dropdown: gr.Dropdown(**subsets),
+            split_dropdown: gr.Dropdown(**splits),
+            input_dataframe: gr.DataFrame(**input_df),
+            dataframe: gr.DataFrame(**input_df),
+            **dict(zip(transform_dropdowns, [gr.Dropdown(**new_transform_dropdown) for new_transform_dropdown in new_transform_dropdowns]))
+        }
+    
+    @dataset_dropdown.select(inputs=dataset_dropdown, outputs=[loading_codes_json, subset_dropdown, split_dropdown, input_dataframe, dataframe] + transform_dropdowns)
+    def _show_subset_dropdown(dataset: str):
+        subsets, loading_codes = show_subset_dropdown(dataset)
+        splits = show_split_dropdown(subsets["value"], loading_codes)
+        input_df, *new_transform_dropdowns = show_input_dataframe(dataset, subsets["value"], splits["value"], loading_codes)
+        return {
+            loading_codes_json: loading_codes,
+            subset_dropdown: gr.Dropdown(**subsets),
+            split_dropdown: gr.Dropdown(**splits),
+            input_dataframe: gr.DataFrame(**input_df),
+            dataframe: gr.DataFrame(**input_df),
+            **dict(zip(transform_dropdowns, [gr.Dropdown(**new_transform_dropdown) for new_transform_dropdown in new_transform_dropdowns]))
+        }
+    
+    @subset_dropdown.select(inputs=[dataset_dropdown, subset_dropdown, loading_codes_json], outputs=[split_dropdown, input_dataframe, dataframe] + transform_dropdowns)
+    def _show_split_dropdown(dataset: str, subset: str, loading_codes: list[dict]):
+        splits = show_split_dropdown(subset, loading_codes)
+        input_df, *new_transform_dropdowns = show_input_dataframe(dataset, subset, splits["value"], loading_codes)
+        return {
+            split_dropdown: gr.Dropdown(**splits),
+            input_dataframe: gr.DataFrame(**input_df),
+            dataframe: gr.DataFrame(**input_df),
+            **dict(zip(transform_dropdowns, [gr.Dropdown(**new_transform_dropdown) for new_transform_dropdown in new_transform_dropdowns]))
+        }
+    
+    @split_dropdown.select(inputs=[dataset_dropdown, subset_dropdown, split_dropdown, loading_codes_json], outputs=[input_dataframe, dataframe] + transform_dropdowns)
+    def _show_input_dataframe(dataset: str, subset: str, split: str, loading_codes: list[dict]) -> pd.DataFrame:
+        input_df, *new_transform_dropdowns = show_input_dataframe(dataset, subset, split, loading_codes)
+        return {
+            input_dataframe: gr.DataFrame(**input_df),
+            dataframe: gr.DataFrame(**input_df),
+            **dict(zip(transform_dropdowns, [gr.Dropdown(**new_transform_dropdown) for new_transform_dropdown in new_transform_dropdowns]))
+        }
 
 
 if __name__ == "__main__":