Update app.py

app.py

@@ -520,6 +520,195 @@ def transform_cols(df: pd.DataFrame, cols: List[str], method="log"):
                 df[c] = df[c].apply(lambda x: np.sqrt(x) if x>=0 else x)
     return df
 
+# -----------------------------
+# Enhanced Data Preparation Functions
+# -----------------------------
+
+def update_column_lists(df):
+    """Update all column dropdowns and checkboxes based on current dataframe"""
+    if df is None or df.empty:
+        return [], [], [], [], [], [], [], [], []
+    
+    cols = df.columns.tolist()
+    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    categorical_cols = df.select_dtypes(include=["object", "category"]).columns.tolist()
+    datetime_cols = df.select_dtypes(include=["datetime64"]).columns.tolist()
+    
+    return (
+        gr.CheckboxGroup.update(choices=cols),  # available_cols
+        gr.Dropdown.update(choices=cols),       # rename_col_old
+        gr.Dropdown.update(choices=cols),       # dtype_col
+        gr.CheckboxGroup.update(choices=numeric_cols),  # num_impute_cols
+        gr.CheckboxGroup.update(choices=categorical_cols),  # cat_impute_cols
+        gr.Dropdown.update(choices=cols),       # replace_col
+        gr.Dropdown.update(choices=categorical_cols),  # split_col
+        gr.Dropdown.update(choices=cols),       # date_col_selected
+        gr.Dropdown.update(choices=cols),       # pivot_index, groupby_cols, etc (simplified)
+    )
+
+def apply_column_operations(df, selected_cols, rename_mapping, dtype_conversions):
+    """Apply column selection, renaming, and type conversions"""
+    df = df.copy()
+    
+    # Column selection
+    if selected_cols:
+        df = df[selected_cols]
+    
+    # Column renaming
+    for old_name, new_name in rename_mapping.items():
+        if old_name in df.columns:
+            df = df.rename(columns={old_name: new_name})
+    
+    # Data type conversions
+    for col, target_dtype in dtype_conversions.items():
+        if col in df.columns:
+            try:
+                if target_dtype == "numeric":
+                    df[col] = pd.to_numeric(df[col], errors='coerce')
+                elif target_dtype == "integer":
+                    df[col] = pd.to_numeric(df[col], errors='coerce').astype('Int64')
+                elif target_dtype == "float":
+                    df[col] = pd.to_numeric(df[col], errors='coerce').astype(float)
+                elif target_dtype == "datetime":
+                    df[col] = pd.to_datetime(df[col], errors='coerce')
+                elif target_dtype == "category":
+                    df[col] = df[col].astype('category')
+                elif target_dtype == "boolean":
+                    df[col] = df[col].astype(bool)
+                # string is default, no conversion needed
+            except Exception as e:
+                print(f"Error converting {col} to {target_dtype}: {e}")
+    
+    return df
+
+def detect_high_cardinality_cols(df, threshold):
+    """Detect columns with high cardinality above threshold"""
+    high_card_cols = []
+    for col in df.columns:
+        if df[col].dtype in ['object', 'category']:
+            unique_count = df[col].nunique()
+            if unique_count > threshold:
+                high_card_cols.append((col, unique_count))
+    return high_card_cols
+
+def advanced_imputation(df, num_cols, num_method, num_custom, cat_cols, cat_method, cat_custom):
+    """Apply advanced imputation methods"""
+    df = df.copy()
+    
+    # Numeric imputation
+    if num_cols:
+        for col in num_cols:
+            if col in df.columns:
+                if num_method == "Mean":
+                    df[col].fillna(df[col].mean(), inplace=True)
+                elif num_method == "Median":
+                    df[col].fillna(df[col].median(), inplace=True)
+                elif num_method == "Mode":
+                    df[col].fillna(df[col].mode()[0] if not df[col].mode().empty else 0, inplace=True)
+                elif num_method == "Zero":
+                    df[col].fillna(0, inplace=True)
+                elif num_method == "Custom Value" and num_custom:
+                    try:
+                        custom_val = float(num_custom)
+                        df[col].fillna(custom_val, inplace=True)
+                    except ValueError:
+                        df[col].fillna(0, inplace=True)
+                elif num_method in ["Forward Fill", "LOCF"]:
+                    df[col].fillna(method='ffill', inplace=True)
+                elif num_method in ["Backward Fill", "NOCB"]:
+                    df[col].fillna(method='bfill', inplace=True)
+                elif num_method == "Linear Interpolation":
+                    df[col].interpolate(method='linear', inplace=True)
+                # Note: KNN and MICE would require more complex implementation
+    
+    # Categorical imputation
+    if cat_cols:
+        for col in cat_cols:
+            if col in df.columns:
+                if cat_method == "Mode":
+                    df[col].fillna(df[col].mode()[0] if not df[col].mode().empty else "Unknown", inplace=True)
+                elif cat_method == "Most Frequent":
+                    df[col].fillna(df[col].value_counts().index[0] if len(df[col].value_counts()) > 0 else "Unknown", inplace=True)
+                elif cat_method == "Arbitrary ('Unknown')":
+                    df[col].fillna("Unknown", inplace=True)
+                elif cat_method == "Constant Value" and cat_custom:
+                    df[col].fillna(cat_custom, inplace=True)
+    
+    return df
+
+def apply_text_operations(df, text_cols, operations):
+    """Apply various text cleaning operations"""
+    df = df.copy()
+    
+    for col in text_cols:
+        if col in df.columns:
+            # Convert to string first
+            df[col] = df[col].astype(str)
+            
+            for op in operations:
+                if op == "Remove leading/trailing whitespace":
+                    df[col] = df[col].str.strip()
+                elif op == "Convert to lowercase":
+                    df[col] = df[col].str.lower()
+                elif op == "Convert to uppercase":
+                    df[col] = df[col].str.upper()
+                elif op == "Remove special characters":
+                    df[col] = df[col].str.replace(r'[^\w\s]', '', regex=True)
+                elif op == "Remove numbers":
+                    df[col] = df[col].str.replace(r'\d+', '', regex=True)
+                elif op == "Remove extra spaces":
+                    df[col] = df[col].str.replace(r'\s+', ' ', regex=True)
+    
+    return df
+
+def split_text_column(df, col, delimiter):
+    """Split text column into multiple columns"""
+    if col not in df.columns:
+        return df, "Column not found"
+    
+    df = df.copy()
+    try:
+        # Split the column
+        split_df = df[col].str.split(delimiter, expand=True)
+        
+        # Name new columns
+        new_col_names = [f"{col}_{i+1}" for i in range(split_df.shape[1])]
+        split_df.columns = new_col_names
+        
+        # Add new columns to original dataframe
+        df = pd.concat([df, split_df], axis=1)
+        
+        return df, f"Successfully split {col} into {len(new_col_names)} columns"
+    except Exception as e:
+        return df, f"Error splitting column: {str(e)}"
+
+def create_formula_column(df, formula, new_col_name):
+    """Create new column based on formula expression"""
+    df = df.copy()
+    
+    try:
+        # Simple formula evaluation (this is a basic implementation)
+        # In a real scenario, you'd want a more sophisticated formula parser
+        if "=" in formula:
+            # Remove the assignment part
+            formula = formula.split("=")[1].strip()
+        
+        # Basic operations support
+        formula = formula.replace("CURRENT_YEAR", str(pd.Timestamp.now().year))
+        
+        # Evaluate the formula (this is simplified)
+        # Note: In production, you'd want a safer evaluation method
+        try:
+            df[new_col_name] = df.eval(formula)
+            return df, f"Successfully created column '{new_col_name}'"
+        except:
+            # Fallback: try as string operation
+            df[new_col_name] = formula
+            return df, f"Created column '{new_col_name}' with constant value"
+            
+    except Exception as e:
+        return df, f"Error creating formula column: {str(e)}"
+
 # -----------------------------
 # Visualization NLP (very small parser)
 # -----------------------------
@@ -945,27 +1134,324 @@ with gr.Blocks(css=css, title="DataSynth — Analytics Hub") as demo:
                         gr.Markdown("### Correlation Analysis")
                         corr_plot = gr.Plot(label="Correlation Heatmap")
                         gr.Markdown("*Note: Only numeric columns are included in correlation analysis*")
-                            
+
             with gr.TabItem("🔧 Prepare"):
-                gr.Markdown("Data cleaning and feature engineering options.")
+                gr.Markdown("## 🛠️ Advanced Data Preparation Studio")
+                
+                with gr.Tabs() as prep_tabs:
+                    # Tab 1: Column Management
+                    with gr.TabItem("📋 Column Management"):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Column Selection & Operations")
+                                available_cols = gr.CheckboxGroup(
+                                    label="Select Columns to Keep",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                select_all_cols = gr.Button("Select All")
+                                deselect_all_cols = gr.Button("Deselect All")
+                                
+                                gr.Markdown("### Column Renaming")
+                                rename_col_old = gr.Dropdown(
+                                    label="Column to Rename",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                rename_col_new = gr.Textbox(
+                                    label="New Column Name",
+                                    placeholder="Enter new column name"
+                                )
+                                rename_btn = gr.Button("Rename Column")
+                                
+                                gr.Markdown("### Data Type Conversion")
+                                dtype_col = gr.Dropdown(
+                                    label="Column to Convert",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                dtype_target = gr.Dropdown(
+                                    label="Target Data Type",
+                                    choices=["string", "numeric", "integer", "float", "datetime", "category", "boolean"],
+                                    value="string",
+                                    interactive=True
+                                )
+                                convert_dtype_btn = gr.Button("Convert Data Type")
+                                
+                            with gr.Column(scale=1):
+                                gr.Markdown("### High Cardinality Management")
+                                high_card_threshold = gr.Slider(
+                                    minimum=1,
+                                    maximum=100,
+                                    value=50,
+                                    step=1,
+                                    label="High Cardinality Threshold (unique values)"
+                                )
+                                high_card_action = gr.Radio(
+                                    choices=["Show only", "Drop columns"],
+                                    value="Show only",
+                                    label="Action for High Cardinality Columns"
+                                )
+                                high_card_btn = gr.Button("Apply High Cardinality Filter")
+                                high_card_results = gr.Markdown("High cardinality columns will appear here")
+                    
+                    # Tab 2: Missing Value Treatment
+                    with gr.TabItem("🎯 Missing Values"):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Numeric Imputation")
+                                num_impute_cols = gr.CheckboxGroup(
+                                    label="Select Numeric Columns",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                num_impute_method = gr.Dropdown(
+                                    choices=[
+                                        "Mean", "Median", "Mode", "KNN", "MICE", 
+                                        "LOCF", "NOCB", "Linear Interpolation", 
+                                        "Forward Fill", "Backward Fill", "Zero", "Custom Value"
+                                    ],
+                                    value="Median",
+                                    label="Imputation Method"
+                                )
+                                num_custom_value = gr.Textbox(
+                                    label="Custom Value (if selected)",
+                                    visible=False
+                                )
+                                
+                                gr.Markdown("### Categorical Imputation")
+                                cat_impute_cols = gr.CheckboxGroup(
+                                    label="Select Categorical Columns",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                cat_impute_method = gr.Dropdown(
+                                    choices=[
+                                        "Mode", "Most Frequent", "Arbitrary ('Unknown')", 
+                                        "KNN", "MICE", "Constant Value"
+                                    ],
+                                    value="Mode",
+                                    label="Imputation Method"
+                                )
+                                cat_custom_value = gr.Textbox(
+                                    label="Custom Value (if selected)",
+                                    value="Unknown",
+                                    visible=False
+                                )
+                                
+                                impute_btn = gr.Button("Apply Imputation")
+                                
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Missing Value Analysis")
+                                missing_summary = gr.Markdown("Missing value summary will appear here")
+                                missing_heatmap = gr.Plot(label="Missing Value Heatmap")
+                    
+                    # Tab 3: Feature Engineering
+                    with gr.TabItem("⚙️ Feature Engineering"):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Text Operations")
+                                text_ops_cols = gr.CheckboxGroup(
+                                    label="Select Text Columns",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                text_operations = gr.CheckboxGroup(
+                                    choices=[
+                                        "Remove leading/trailing whitespace",
+                                        "Convert to lowercase", 
+                                        "Convert to uppercase",
+                                        "Remove special characters",
+                                        "Remove numbers",
+                                        "Remove extra spaces"
+                                    ],
+                                    label="Text Operations"
+                                )
+                                
+                                gr.Markdown("### Value Replacement")
+                                replace_col = gr.Dropdown(
+                                    label="Column for Value Replacement",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                replace_old = gr.Textbox(
+                                    label="Value to Replace",
+                                    placeholder="Enter value to find"
+                                )
+                                replace_new = gr.Textbox(
+                                    label="Replacement Value", 
+                                    placeholder="Enter new value"
+                                )
+                                replace_btn = gr.Button("Replace Values")
+                                
+                                gr.Markdown("### Text to Columns")
+                                split_col = gr.Dropdown(
+                                    label="Column to Split",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                split_delimiter = gr.Textbox(
+                                    label="Delimiter",
+                                    value=",",
+                                    placeholder="Enter delimiter (e.g., ',', ';', ' ')",
+                                    max_lines=1
+                                )
+                                split_btn = gr.Button("Split Column")
+                                
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Formula-Based Columns")
+                                formula_expr = gr.Textbox(
+                                    label="Formula Expression",
+                                    placeholder="Example: Sales * Quantity, or LEFT(ProductName, 3)",
+                                    lines=2
+                                )
+                                formula_new_col = gr.Textbox(
+                                    label="New Column Name",
+                                    placeholder="Enter name for new column"
+                                )
+                                formula_examples = gr.Markdown("""
+                                **Formula Examples:**
+                                - `Revenue = Sales * Price`
+                                - `FullName = FirstName + ' ' + LastName`  
+                                - `Profit = Revenue - Cost`
+                                - `Category = LEFT(ProductCode, 3)`
+                                - `Age = CURRENT_YEAR - BirthYear`
+                                """)
+                                formula_btn = gr.Button("Create New Column")
+                                
+                                gr.Markdown("### Date Operations")
+                                date_col_selected = gr.Dropdown(
+                                    label="Date Column",
+                                    choices=[],
+                                    interactive=True
+                                )
+                                date_operations = gr.CheckboxGroup(
+                                    choices=[
+                                        "Extract Year", "Extract Month", "Extract Day",
+                                        "Extract Quarter", "Extract Day of Week",
+                                        "Calculate Age", "Calculate Days Difference"
+                                    ],
+                                    label="Date Operations"
+                                )
+                                date_btn = gr.Button("Apply Date Operations")
+                    
+                    # Tab 4: Transformations
+                    with gr.TabItem("🔄 Transformations"):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Pivot/Unpivot")
+                                transform_type = gr.Radio(
+                                    choices=["Pivot", "Unpivot", "Transpose"],
+                                    label="Transformation Type"
+                                )
+                                
+                                gr.Markdown("#### Pivot Options")
+                                pivot_index = gr.Dropdown(
+                                    label="Index Columns",
+                                    choices=[],
+                                    interactive=True,
+                                    multiselect=True
+                                )
+                                pivot_columns = gr.Dropdown(
+                                    label="Columns to Pivot",
+                                    choices=[],
+                                    interactive=True,
+                                    multiselect=True
+                                )
+                                pivot_values = gr.Dropdown(
+                                    label="Values Columns",
+                                    choices=[],
+                                    interactive=True,
+                                    multiselect=True
+                                )
+                                
+                                gr.Markdown("#### Group By & Summarize")
+                                groupby_cols = gr.Dropdown(
+                                    label="Group By Columns",
+                                    choices=[],
+                                    interactive=True,
+                                    multiselect=True
+                                )
+                                agg_columns = gr.Dropdown(
+                                    label="Columns to Aggregate",
+                                    choices=[],
+                                    interactive=True,
+                                    multiselect=True
+                                )
+                                agg_functions = gr.Dropdown(
+                                    choices=["sum", "mean", "median", "min", "max", "count", "std"],
+                                    label="Aggregation Function",
+                                    multiselect=True
+                                )
+                                
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Data Combination")
+                                combo_type = gr.Radio(
+                                    choices=["Append (Union)", "Join", "Merge"],
+                                    label="Combination Type"
+                                )
+                                
+                                gr.Markdown("#### Join/Merge Options")
+                                join_type = gr.Dropdown(
+                                    choices=["inner", "left", "right", "outer"],
+                                    value="inner",
+                                    label="Join Type",
+                                    visible=False
+                                )
+                                join_key = gr.Dropdown(
+                                    label="Join Key Column",
+                                    choices=[],
+                                    interactive=True,
+                                    visible=False
+                                )
+                                
+                                upload_second_df = gr.File(
+                                    label="Upload Second Dataset for Combination",
+                                    file_types=[".csv", ".xlsx", ".xls"],
+                                    visible=False
+                                )
+                                
+                                transform_btn = gr.Button("Apply Transformation")
+                                combo_btn = gr.Button("Combine Data", visible=False)
+                    
+                    # Tab 5: Data Preview & Actions
+                    with gr.TabItem("👁️ Data Preview"):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Interactive Data Grid")
+                                gr.Markdown("""
+                                **Features:**
+                                - Sort by clicking column headers
+                                - Filter using column menu
+                                - Copy values with Ctrl+C
+                                - Select multiple rows
+                                """)
+                                
+                                row_count = gr.Slider(
+                                    minimum=10,
+                                    maximum=1000,
+                                    value=100,
+                                    step=10,
+                                    label="Number of Rows to Display"
+                                )
+                                
+                                duplicate_btn = gr.Button("📋 Duplicate Current Dataset")
+                                reset_btn = gr.Button("🔄 Reset to Original Data")
+                                
+                            with gr.Column(scale=2):
+                                interactive_preview = gr.Dataframe(
+                                    interactive=True,
+                                    label="Interactive Data Preview",
+                                    wrap=True
+                                )
+                
+                # Global Actions at Bottom
                 with gr.Row():
-                    with gr.Column(scale=1):
-                        impute_num = gr.Dropdown(choices=["mean","median","most_frequent"], value="mean", label="Numeric Imputation")
-                        impute_cat = gr.Dropdown(choices=["most_frequent","constant"], value="most_frequent", label="Categorical Imputation")
-                        const_fill = gr.Textbox(label="Constant fill value (if constant chosen)", value="missing")
-                        outlier_cols = gr.Textbox(label="Outlier numeric columns (comma separated) — leave blank for auto numeric")
-                        outlier_method = gr.Dropdown(choices=["cap","remove"], value="cap", label="Outlier treatment")
-                        date_col = gr.Dropdown(choices=[], label="Date column (auto-detected)", interactive=True)
-                        date_fmt = gr.Textbox(label="Date format (optional)", placeholder="%Y-%m-%d")
-                        text_cols = gr.Textbox(label="Text columns to clean (comma separated)")
-                        transform_cols_txt = gr.Textbox(label="Numeric columns to transform (comma separated)")
-                        transform_method = gr.Dropdown(choices=["log","sqrt"], value="log", label="Transform method")
-                        drop_highcard = gr.Checkbox(label="Auto-drop high-cardinality categorical columns", value=True)
-                        apply_prep = gr.Button("Apply Preparation")
-                        download_clean = gr.Button("Download Clean CSV")
-                    with gr.Column(scale=1):
-                        prep_output = gr.Markdown("Preparation preview will appear here.")
-                        preview_clean = gr.Dataframe(interactive=False)
+                    apply_all_btn = gr.Button("🚀 Apply All Changes", variant="primary", size="lg")
+                    download_clean_btn = gr.Button("📥 Download Clean CSV", variant="secondary")
+                
+                prep_output = gr.Markdown("Preparation status will appear here")
+                
             with gr.TabItem("📊 Visualize (NL)"):
                 gr.Markdown("Type a natural-language request to create a plot (e.g., 'histogram of age', 'scatter income vs age', 'bar of country').")
                 nl_input = gr.Textbox(label="Describe chart")
@@ -1107,6 +1593,112 @@ with gr.Blocks(css=css, title="DataSynth — Analytics Hub") as demo:
 
     download_clean.click(fn=lambda p: p if p else None, inputs=[clean_state], outputs=[download_clean])
 
+        # Prepare tab callbacks
+    def _update_prepare_ui(df_path):
+        """Update all UI elements when prepare tab is loaded"""
+        if not df_path:
+            return update_column_lists(None)
+        
+        df = pd.read_csv(df_path)
+        return update_column_lists(df)
+
+    # When prepare tab is selected, update the UI
+    prep_tabs.select(
+        fn=_update_prepare_ui,
+        inputs=[df_state],
+        outputs=[
+            available_cols, rename_col_old, dtype_col, num_impute_cols, 
+            cat_impute_cols, replace_col, split_col, date_col_selected, pivot_index
+        ]
+    )
+
+    def _apply_all_preparations(df_path, selected_cols, high_card_threshold, high_card_action):
+        """Apply all preparation steps"""
+        try:
+            if not df_path:
+                return "No dataset loaded", None
+            
+            df = pd.read_csv(df_path)
+            
+            # Apply column selection
+            if selected_cols:
+                df = df[selected_cols]
+            
+            # Apply high cardinality filtering
+            high_card_cols = detect_high_cardinality_cols(df, high_card_threshold)
+            if high_card_action == "Drop columns" and high_card_cols:
+                cols_to_drop = [col for col, count in high_card_cols]
+                df = df.drop(columns=cols_to_drop)
+            
+            # Save cleaned data
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv")
+            df.to_csv(tmp.name, index=False)
+            
+            summary = f"""
+            **Preparation Summary:**
+            - Final dataset: {len(df)} rows, {len(df.columns)} columns
+            - High cardinality columns found: {len(high_card_cols)}
+            - Columns kept: {', '.join(df.columns.tolist())}
+            """
+            
+            return summary, tmp.name
+            
+        except Exception as e:
+            return f"Preparation failed: {str(e)}", None
+
+    apply_all_btn.click(
+        fn=_apply_all_preparations,
+        inputs=[df_state, available_cols, high_card_threshold, high_card_action],
+        outputs=[prep_output, clean_state]
+    )
+
+    # Column selection helpers
+    def _select_all_cols(df_path):
+        if not df_path:
+            return gr.CheckboxGroup.update(choices=[])
+        df = pd.read_csv(df_path)
+        return gr.CheckboxGroup.update(value=df.columns.tolist())
+
+    def _deselect_all_cols():
+        return gr.CheckboxGroup.update(value=[])
+
+    select_all_cols.click(fn=_select_all_cols, inputs=[df_state], outputs=[available_cols])
+    deselect_all_cols.click(fn=_deselect_all_cols, outputs=[available_cols])
+
+    # Show/hide custom value inputs based on method selection
+    def _toggle_custom_inputs(num_method, cat_method):
+        num_visible = num_method == "Custom Value"
+        cat_visible = cat_method == "Constant Value"
+        return (
+            gr.Textbox.update(visible=num_visible),
+            gr.Textbox.update(visible=cat_visible)
+        )
+
+    num_impute_method.change(
+        fn=_toggle_custom_inputs,
+        inputs=[num_impute_method, cat_impute_method],
+        outputs=[num_custom_value, cat_custom_value]
+    )
+    
+    cat_impute_method.change(
+        fn=_toggle_custom_inputs, 
+        inputs=[num_impute_method, cat_impute_method],
+        outputs=[num_custom_value, cat_custom_value]
+    )
+
+    # Data duplication
+    def _duplicate_dataset(df_path):
+        if not df_path:
+            return None
+        # Create a copy of the current dataset
+        import shutil
+        import tempfile
+        new_path = tempfile.NamedTemporaryFile(delete=False, suffix=".csv")
+        shutil.copy2(df_path, new_path.name)
+        return new_path.name
+
+    duplicate_btn.click(fn=_duplicate_dataset, inputs=[df_state], outputs=[df_state])
+
     # NLP visualize
     def _nl_visualize(query, clean_path, df_path):
         try: