Update app.py

app.py

@@ -1,805 +1,805 @@
-import io
-import streamlit as st
-import pandas as pd
-import csv
-import re
-import plotly.express as px
-from scipy.stats import skew
-from prompt_models import *
-from execution_programs import *
-from llm_models import text_llm, code_llm
-
-st.set_page_config(layout="wide")
-    
-# Custom style CSS
-st.markdown("""
-<style>
-    .block-container {
-        padding-top: 1rem;
-        padding-bottom: 1rem;
-        padding-left: 0rem;
-        padding-right: 0rem;
-    }
-    .element-container:has(.stColumn) {
-        gap: 0rem !important;
-    }
-    div[data-testid="column"] {
-        padding-left: 0rem !important;
-        padding-right: 0rem !important;
-    }
-    .stApp {
-        max-width: 1200px;
-        margin: 0 auto;
-        padding: 1rem;
-    }
-    .cell {
-        border: 1px solid #e0e0e0;
-        border-radius: 4px;
-        padding: 1rem;
-        margin-bottom: 1.5rem;
-        background-color: #f9f9f9;
-    }
-    .output {
-        border-left: 3px solid #4285f4;
-        padding-left: 1rem;
-        margin-top: 0.5rem;
-    }
-    .input-area {
-        background-color: #f5f5f5;
-        padding: 1rem;
-        border-radius: 4px;
-        margin-bottom: 1rem;
-    }
-    .stButton > button {
-        padding: 0rem 0.5rem; 
-        border-radius: 5px; 
-        font-size: 16px; 
-        font-weight: bold; 
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); 
-        transition: all 0.3s ease; 
-    }
-
-    .stButton > button:hover {
-        background-color: #357ae8; 
-        border-color: #357ae8; 
-        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15); 
-    }
-    .history-item {
-        margin-bottom: 2rem;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-    }
-    .chat-message {
-        padding: 1rem;
-        border-radius: 0.5rem;
-        margin-bottom: 1rem;
-        display: flex;
-    }
-    .chat-message.user {
-        background-color: #262626;
-        align-self: flex-start;  
-    }
-    .chat-message.assistant {
-        background-color: #262626;
-        align-self: flex-end; 
-    }
-    .chat-message {
-            font-size: 14px; 
-    }
-    .chat-message.user {
-            font-size: 16px;  
-    }
-    .chat-message.assistant {
-            font-size: 14px; 
-    }
-    .sidebar {
-        width: 300px;
-        padding-right: 2rem;
-    }
-    .delete-btn {
-        background-color: #ff4b4b !important;
-        color: white !important;
-        border: none !important;
-        padding: 0.25rem 0.5rem !important;
-        font-size: 0.8rem !important;
-        margin-top: 0.5rem;
-    }
-    .delete-btn:hover {
-        background-color: #ff0000 !important;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize session state
-if 'execution_history' not in st.session_state:
-    st.session_state.execution_history = []
-if 'df' not in st.session_state:
-    st.session_state.df = None
-
-
-# Main app layout
-col1a, col2a = st.columns([4, 7], gap="small")
-st.markdown("<div style='margin-top: 5px'></div>", unsafe_allow_html=True)
-show_col1 = st.toggle("Ask chat bot", value=True)
-
-if show_col1:
-    col1a, col2a = st.columns([4,7]) 
-else:
-    _ , col2a = st.columns([0.0001, 2]) 
-    
-with col1a:
-  if show_col1:
-    with st.container(height=570):
-        st.header("💬 Chatbot Assistant")
-        
-        # Initial state
-        if 'chatbot' not in st.session_state:
-            st.session_state.chatbot = {
-                'chat_history': [],
-                'prev_df': None,
-                'prev_raw_dataframes': None
-            }
-        
-        # button clear all chat
-        if st.button("🗑️ Clear all chat", key="clear_all_chat"):
-            st.session_state.chatbot['chat_history'] = []
-        
-        # show history chatbot
-        for i in range(0, len(st.session_state.chatbot['chat_history']), 2):
-            user_msg = st.session_state.chatbot['chat_history'][i]
-            assistant_msg = st.session_state.chatbot['chat_history'][i+1] if i+1 < len(st.session_state.chatbot['chat_history']) else None
-
-            with st.expander(f"Chat {i//2 + 1}", expanded=False):
-                with st.chat_message("user"):
-                    st.markdown(user_msg["content"])
-                if assistant_msg:
-                    with st.chat_message("assistant"):
-                        st.markdown(assistant_msg["content"])
-
-        
-        # Input chat
-        user_query = st.chat_input("Ask coding questions...", key="chatbot_input")
-
-        if user_query:
-            # save previous state
-            st.session_state.chatbot['prev_df'] = st.session_state.get('df')
-            st.session_state.chatbot['prev_raw_dataframes'] = st.session_state.get('raw_dataframes')
-            
-            # show chat user
-            with st.chat_message("user"):
-                st.markdown(user_query)
-            
-            # add to history chat
-            st.session_state.chatbot['chat_history'].append({"role": "user", "content": user_query})
-            
-            with st.spinner("Thinking..."):
-                if "df" in st.session_state:
-                    try:
-                        df = st.session_state.df
-                        columns = df.columns
-                        shape = df.shape
-                        dtypes = df.dtypes
-                        response = text_llm(prompt_chatbot(user_query,st.session_state.df.columns, st.session_state.df.shape, st.session_state.df.dtypes))
-                        clean_response = re.sub(r'<\s*think\s*>.*?<\s*/\s*think\s*>', '', response, flags=re.DOTALL | re.IGNORECASE)
-                        
-                        # show and save chatbot response
-                        with st.chat_message("assistant"):
-                            st.markdown(clean_response)
-                        st.session_state.chatbot['chat_history'].append({"role": "assistant", "content": clean_response})
-                    except AttributeError as e:
-                        st.error(f"Please confirm dataset before starting the chat: {e}")
-                else:
-                    st.write('You need to upload the data first')
-
-with col2a:  # Sidebar for chatbot
-    with st.container(height=570):
-        st.header("📊 Chatbot Data Analysis Coder")
-        st.markdown("Analyze your CSV data with LLM Models")
-
-        def reset_data_state():
-            st.session_state.df = None
-            st.session_state.raw_dataframes = None
-            st.session_state.preview_df = None
-            st.session_state.file_names = [f.name for f in uploaded_files] if uploaded_files else []
-
-        # Initialize session state if not already present
-        if 'df' not in st.session_state:
-            st.session_state.df = None
-
-        uploaded_files = st.file_uploader(
-            "Upload CSV file(s)", 
-            type=["csv"], 
-            accept_multiple_files=True,
-            help="Upload one or more CSV files to combine"
-        )
-
-        if uploaded_files:
-            # Reset processing if files change
-            if 'prev_uploaded_files' not in st.session_state or st.session_state.prev_uploaded_files != [f.name for f in uploaded_files]:
-                st.session_state.df = None
-                st.session_state.raw_dataframes = None
-                st.session_state.preview_df = None
-                st.session_state.prev_uploaded_files = [f.name for f in uploaded_files]
-            
-            # Process files but don't merge yet
-            if st.session_state.raw_dataframes is None:
-                dataframes = []
-                processed_files = 0
-                
-                for uploaded_file in uploaded_files:
-                    with st.expander(f"📄 File: {uploaded_file.name}", expanded=False):
-                        try:
-                            # Try to detect delimiter
-                            raw_data = uploaded_file.getvalue().decode("utf-8")
-                            sniffer = csv.Sniffer()
-                            
-                            try:
-                                dialect = sniffer.sniff(raw_data.splitlines()[0])
-                                delimiter = dialect.delimiter
-                            except (csv.Error, IndexError):
-                                # Try common delimiters if sniffing fails
-                                for test_delim in [',', ';', '\t', '|']:
-                                    if test_delim in raw_data:
-                                        delimiter = test_delim
-                                        break
-                                else:
-                                    delimiter = ','  # default
-                            
-                            uploaded_file.seek(0)  # Reset file pointer
-                            
-                            # Read CSV with error handling
-                            try:
-                                df = pd.read_csv(uploaded_file, delimiter=delimiter, on_bad_lines='warn')
-                            except Exception as e:
-                                st.warning(f"Using Python engine for {uploaded_file.name} due to parsing issues")
-                                df = pd.read_csv(uploaded_file, delimiter=delimiter, engine='python')
-                            
-                            # Display file info
-                            st.write(f"Shape: {df.shape}")
-                            st.write(f"Detected delimiter: '{delimiter}'")
-                            st.dataframe(df.head(5), use_container_width=True)
-                            
-                            dataframes.append(df)
-                            processed_files += 1
-                            
-                        except Exception as e:
-                            st.error(f"Error processing {uploaded_file.name}: {str(e)}")
-                            continue
-                
-                if processed_files == 0:
-                    st.error("No files were successfully processed")
-                    st.stop()
-                
-                # Store raw dataframes in session state
-                st.session_state.raw_dataframes = dataframes
-            
-            # Only proceed if we have raw dataframes
-            if st.session_state.raw_dataframes:
-                dataframes = st.session_state.raw_dataframes
-                
-                col1, col2 = st.columns([3, 1])
-                
-                with col1:
-                    merge_option = st.radio(
-                        "Merge method:",
-                        ("single data","Horizontal (concat columns)", "Vertical (concat rows)", "Horizontal (merge on common columns)"),
-                        index=0,
-                        horizontal=True,
-                        key="merge_option"
-                    )
-                    
-                    # Additional merge parameters
-                    if merge_option == "Horizontal (merge on common columns)":
-                        if len(dataframes) > 0:
-                            common_cols = set(dataframes[0].columns)
-                            for df in dataframes[1:]:
-                                common_cols.intersection_update(df.columns)
-                            
-                            if common_cols:
-                                selected_cols = st.multiselect(
-                                    "Select columns to merge on:",
-                                    options=list(common_cols),
-                                    default=list(common_cols),
-                                    key="merge_columns"
-                                )
-                                how_merge = st.selectbox(
-                                    "Merge type:",
-                                    ["inner", "outer", "left", "right"],
-                                    index=1,
-                                    key="how_merge"
-                                )
-                            else:
-                                None
-                
-                with col2:
-                    preview_button = st.button("🔄 Preview")
-                    confirm_button = st.button("✅ Confirm")
-                    reset_btn = st.button("🔄 Reset")
-                
-                # Reset logic
-                if reset_btn:
-                    reset_data_state()
-                    st.rerun()
-                
-                # Preview logic
-                if preview_button:
-                    with st.spinner("Generating preview..."):
-                        try:
-                            if merge_option == "single data":
-                                preview_df = dataframes[0]
-                            elif merge_option == "Horizontal (concat columns)":
-                                # Find common indices across ALL dataframes
-                                common_indices = dataframes[0].index
-                                for df in dataframes[1:]:
-                                    common_indices = common_indices.intersection(df.index)
-                                
-                                if len(common_indices) == 0:
-                                    st.error("No common indices found across all dataframes")
-                                    st.stop()
-                                
-                                # Filter all dataframes to only common indices
-                                filtered_dfs = [df.loc[common_indices] for df in dataframes]
-                                
-                                # Handle duplicate column names
-                                all_columns = []
-                                duplicate_counter = {}
-                                
-                                for i, df in enumerate(filtered_dfs):
-                                    new_columns = []
-                                    for col in df.columns:
-                                        if col in all_columns:
-                                            if col not in duplicate_counter:
-                                                duplicate_counter[col] = 1
-                                            duplicate_counter[col] += 1
-                                            new_col = f"{col}_df{duplicate_counter[col]}"
-                                            new_columns.append(new_col)
-                                        else:
-                                            new_columns.append(col)
-                                    all_columns.extend(new_columns)
-                                    filtered_dfs[i].columns = new_columns
-                                
-                                # Concatenate horizontally
-                                preview_df = pd.concat(filtered_dfs, axis=1)
-                                
-                            elif merge_option == "Vertical (concat rows)":
-                                preview_df = pd.concat(dataframes, axis=0, ignore_index=True)
-                                
-                            elif merge_option == "Horizontal (merge on common columns)":
-                                def auto_merge_many(dfs):
-                                    if not dfs:
-                                        return None
-                                    
-                                    merged_df = dfs[0]
-                                    
-                                    for next_df in dfs[1:]:
-                                        common_keys = list(set(merged_df.columns) & set(next_df.columns))
-                                        if common_keys:
-                                            merged_df = pd.merge(merged_df, next_df, on=common_keys)
-                                        else:
-                                            print(f"[WARNING] There is no matching key between:\n{merged_df.columns}\n&\n{next_df.columns}")
-                                    
-                                    return merged_df
-                                
-                                preview_df = auto_merge_many(dataframes)
-                            
-                            st.session_state.preview_df = preview_df
-                            st.success("Preview generated!")
-                            
-                            # Show preview stats
-                            st.subheader("Preview Results")
-                            st.write(f"Shape: {preview_df.shape}")
-                            
-                            # Show sample data with tabs
-                            tab1, tab2 = st.tabs(["First Rows", "Last Rows"])
-                            with tab1:
-                                st.dataframe(preview_df.head(20), use_container_width=True)
-                            with tab2:
-                                st.dataframe(preview_df.tail(20), use_container_width=True)
-                            
-                            # Show quick stats
-                            with st.expander("Preview Statistics"):
-                                st.write("Column types:")
-                                st.dataframe(preview_df.dtypes.astype(str).reset_index().rename(
-                                    columns={'index': 'Column', 0: 'DataType'}
-                                ))
-                                
-                                st.write("Missing values:")
-                                missing = preview_df.isnull().sum()
-                                missing = missing[missing > 0].reset_index().rename(
-                                    columns={'index': 'Column', 0: 'Missing Count'}
-                                )
-                                if len(missing) > 0:
-                                    st.dataframe(missing)
-                                else:
-                                    st.success("No missing values found!")
-                        
-                        except Exception as e:
-                            st.error(f"Preview failed: {str(e)}")
-                            st.stop()
-                
-                # Confirm merge logic
-                if confirm_button and st.session_state.preview_df is not None:
-                    st.session_state.df = st.session_state.preview_df
-                    st.session_state.preview_df = None  # Clear preview after confirmation
-                    st.success("Data is now available for analysis.")
-                    st.balloons()
-                    st.rerun()
-                
-                # Show raw data info
-                with st.expander("📦 Raw Data Summary", expanded=False):
-                    st.write(f"Total files loaded: {len(dataframes)}")
-                    for i, df in enumerate(dataframes, 1):
-                        st.write(f"### Dataframe {i}")
-                        st.write(f"- Shape: {df.shape}")
-                        st.write("- Columns:")
-                        st.dataframe(pd.DataFrame({
-                            'Column': df.columns,
-                            'Type': df.dtypes.values,
-                            'Missing %': (df.isnull().mean() * 100).round(2)
-                        }), hide_index=True)
-                        
-                        if st.checkbox(f"Show sample data for Dataframe {i}", key=f"show_raw_{i}"):
-                            st.dataframe(df.head(5), use_container_width=True)
-            
-            # If merge is already confirmed, show the final data
-            if st.session_state.df is not None:
-                
-                # Data cleaning options (only after merge is confirmed)
-                with st.expander("**🧹 Data Cleaning**", expanded=True):
-                    # Inisialisasi df_cleaned di session state jika belum ada
-
-                    st.session_state.df_cleaned = st.session_state.df.copy()
-                    
-                    clean_options = st.columns(4)
-                    
-                    with clean_options[0]:
-                        clean_nan = st.selectbox(
-                            "Handle NaN values:",
-                            ["Keep", "Remove rows", "Fill with zero", "Fill with mean"],
-                            index=0,
-                            key="clean_nan"
-                        )
-                        
-                        if st.button("Apply NaN Handling"):
-                            if clean_nan == "Fill with zero":
-                                st.session_state.df_cleaned = st.session_state.df_cleaned.fillna(0)
-                                st.success("Filled NaN with zeros!")
-                            elif clean_nan == "Fill with mean":
-                                st.session_state.df_cleaned = st.session_state.df_cleaned.fillna(st.session_state.df_cleaned.mean())
-                                st.success("Filled NaN with mean values!")
-                            elif clean_nan == "Remove rows":
-                                initial_rows = len(st.session_state.df_cleaned)
-                                st.session_state.df_cleaned = st.session_state.df_cleaned.dropna()
-                                removed_nan = initial_rows - len(st.session_state.df_cleaned)
-                                st.success(f"Removed {removed_nan} rows with NaN values!")
-                    
-                    with clean_options[1]:
-                        clean_duplicates = st.selectbox(
-                            "Handle duplicates:",
-                            ["Keep", "Remove all", "Keep first", "Keep last"],
-                            index=0,
-                            key="clean_duplicates"
-                        )
-                        
-                        if st.button("Apply Deduplication"):
-                            if clean_duplicates != "Keep":
-                                initial_rows = len(st.session_state.df_cleaned)
-                                if clean_duplicates == "Remove all":
-                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop_duplicates(keep=False)
-                                elif clean_duplicates == "Keep first":
-                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop_duplicates(keep='first')
-                                elif clean_duplicates == "Keep last":
-                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop_duplicates(keep='last')
-                                
-                                removed_dups = initial_rows - len(st.session_state.df_cleaned)
-                                st.success(f"Removed {removed_dups} duplicate rows!")
-                    
-                    with clean_options[2]:
-                        col_rename = st.text_input("Rename ('old:new')")
-                        if st.button("Rename Column") and col_rename and ":" in col_rename:
-                            old, new = col_rename.split(":", 1)
-                            if old in st.session_state.df_cleaned.columns:
-                                st.session_state.df_cleaned = st.session_state.df_cleaned.rename(columns={old: new})
-                                st.success(f"Renamed column '{old}' to '{new}'")
-                            else:
-                                st.warning(f"Column '{old}' not found")
-                                
-                    with clean_options[3]:
-                        # Fitur Drop Columns
-                        cols_to_drop = st.text_input(
-                            "Drop columns", 
-                            placeholder="column1, column2, ...",
-                            key="drop_cols_input"
-                        )
-                        
-                        if st.button("Drop Columns"):
-                            if cols_to_drop:
-                                # Proses input: hilangkan spasi, split by comma, dan bersihkan
-                                columns_list = [col.strip() for col in cols_to_drop.split(",") if col.strip()]
-                                
-                                # Fungsi untuk mencocokkan nama kolom dengan fleksibilitas
-                                def find_matching_column(col_name, df_columns):
-                                    col_name = col_name.lower().strip()
-                                    for df_col in df_columns:
-                                        if df_col.lower().strip() == col_name:
-                                            return df_col
-                                    return None
-                                
-                                # Cari kolom yang cocok
-                                matched_cols = []
-                                not_found = []
-                                
-                                for col in columns_list:
-                                    matched = find_matching_column(col, st.session_state.df_cleaned.columns)
-                                    if matched:
-                                        matched_cols.append(matched)
-                                    else:
-                                        not_found.append(col)
-                                
-                                # Drop kolom yang ditemukan
-                                if matched_cols:
-                                    initial_cols = st.session_state.df_cleaned.columns.tolist()
-                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop(columns=matched_cols)
-                                    st.success(f"Successfully dropped columns: {', '.join(matched_cols)}")
-                                    
-                                    # Tampilkan warning untuk kolom yang tidak ditemukan
-                                    if not_found:
-                                        st.warning(f"Columns not found: {', '.join(not_found)}")
-                                    
-                                    # Tampilkan perubahan
-                                    st.write(f"Remaining columns: {len(st.session_state.df_cleaned.columns)}")
-                                else:
-                                    st.error("No matching columns found to drop")
-                            else:
-                                st.warning("Please enter column names to drop")
-
-                    # Tampilkan info missing values setelah cleaning
-                    missing_values = st.session_state.df_cleaned.isnull().sum().sum()
-                    duplicate_values = st.session_state.df_cleaned.duplicated().sum().sum()
-                    if missing_values > 0 or duplicate_values > 0:
-                        st.warning(f"⚠️ Warning: There are still {missing_values} missing values and {duplicate_values} ducplicate rows in the data")
-                    else:
-                        st.success("✅ No missing values and duplicate rows remaining!")
-                
-                # Final data display
-                st.session_state.df = st.session_state.df_cleaned
-                st.subheader("📊 Final Data")
-                st.write(f"Shape: {st.session_state.df.shape}")
-                
-                # Interactive data explorer
-                tab1, tab2, tab3, tab4 = st.tabs(["Data View", "Statistics", "Column Analysis", 'Type Data'])
-                
-                with tab1:
-                    num_rows = st.slider(
-                        "Number of rows to display:",
-                        min_value=5,
-                        max_value=100,
-                        value=5,
-                        key="num_rows_view"
-                    )
-                    st.dataframe(st.session_state.df.head(num_rows), use_container_width=True)
-                
-                with tab2:
-                    st.write("### Descriptive Statistics")
-                    st.dataframe(st.session_state.df.describe(include='all'), use_container_width=True)
-                    
-                
-                with tab3:
-                    selected_col = st.selectbox(
-                        "Select column to analyze:",
-                        st.session_state.df.columns,
-                        key="col_analyze"
-                    )
-                    
-                    col_data = st.session_state.df[selected_col]
-                    st.write(f"**Type:** {col_data.dtype}")
-                    st.write(f"**Unique values:** {len(col_data.unique())}")
-                    st.write(f"**Missing values:** {col_data.isnull().sum()} ({col_data.isnull().mean()*100:.2f}%)")
-                    
-
-                    if col_data.nunique() < 20 and not pd.api.types.is_numeric_dtype(col_data):
-                        ascending = st.checkbox("Ascending", value=False)
-                        st.write("**Distribution**")
-                        column_name = col_data.name
-
-                        # sum and sort data
-                        counts = col_data.value_counts(ascending=ascending)
-                        ordered_categories = counts.index.tolist()
-
-                        # create dataframe and category for data
-                        df_temp = pd.DataFrame({column_name: col_data})
-                        df_temp[column_name] = pd.Categorical(df_temp[column_name], categories=ordered_categories, ordered=True)
-
-                        # create histogram
-                        fig = px.histogram(
-                            df_temp,
-                            x=column_name,
-                            opacity=0.7,
-                            color_discrete_sequence=["#d06200"],
-                        )
-
-                        fig.update_traces(marker_line_color='gray', marker_line_width=1)
-
-                        # Show x axis based on category sorting
-                        fig.update_layout(
-                            template='seaborn',
-                            title=f"Histogram of {column_name}",
-                            xaxis_title=column_name,
-                            yaxis_title="Count",
-                            bargap=0.1,
-                            font=dict(family="Verdana", size=13),
-                            xaxis=dict(
-                                categoryorder="array",
-                                categoryarray=ordered_categories,
-                            )
-                        )
-
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    elif pd.api.types.is_numeric_dtype(col_data):
-                        st.write("**Distribution**")
-                        column_name = col_data.name
-
-                        df_temp = pd.DataFrame({column_name: col_data.dropna()})
-                        
-                        fig = px.histogram(
-                            df_temp,
-                            x=column_name,
-                            nbins=30,
-                            opacity=0.85,
-                            color_discrete_sequence=["#d06200"],
-                        )
-
-                        fig.update_traces(marker_line_color='gray', marker_line_width=0.9)
-
-                        fig.update_layout(
-                            template='seaborn',
-                            title=f"Histogram of {column_name}",
-                            xaxis_title=column_name,
-                            yaxis_title="Count",
-                            bargap=0.1,
-                            font=dict(family="Verdana", size=13),
-                        )
-                        fig.update_layout(
-                            annotations=[
-                                dict(
-                                    text=f"Skewness: {skew(col_data):.2f}",
-                                    showarrow=False,
-                                    xref="paper", yref="paper",
-                                    x=0.95, y=0.95,
-                                    bordercolor='black',
-                                    borderwidth=1
-                                )
-                            ]
-                        )
-
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    else:
-                        st.write("**Value counts (top 20):**")
-                        st.dataframe(col_data.value_counts().head(20))
-
-
-                with tab4:
-                    buffer = io.StringIO()
-                    st.session_state.df.info(buf=buffer)
-                    st.text(buffer.getvalue())
-
-                    st.markdown("**Data Types:**")
-                    st.json(st.session_state.df.dtypes.astype(str).to_dict())
-
-                    st.markdown("**Missing Values:**")
-                    st.json(st.session_state.df.isnull().sum().to_dict())
-
-                    st.markdown("**Duplicate:**")
-                    duplicate_count = st.session_state.df.duplicated().sum()
-                    st.write(f"Total duplicate row: {duplicate_count}")
-
-                    # Menampilkan jumlah duplikat dalam format JSON yang benar
-                    st.json({"duplicate_count": duplicate_count})
-
-                
-                # Export options
-                with st.expander("💾 Export Data", expanded=False):
-                    export_format = st.radio(
-                        "Export format:",
-                        ["CSV", "Excel", "JSON"],
-                        horizontal=True
-                    )
-                    
-                    export_filename = st.text_input("Filename (without extension)", "clean_data")
-                    
-                    if st.button("Export Data"):
-                        try:
-                            if export_format == "CSV":
-                                csv = st.session_state.df.to_csv(index=False).encode('utf-8')
-                                st.download_button(
-                                    label="Download CSV",
-                                    data=csv,
-                                    file_name=f"{export_filename}.csv",
-                                    mime='text/csv'
-                                )
-                            elif export_format == "Excel":
-                                excel_buffer = io.BytesIO()
-                                st.session_state.df.to_excel(excel_buffer, index=False)
-                                st.download_button(
-                                    label="Download Excel",
-                                    data=excel_buffer,
-                                    file_name=f"{export_filename}.xlsx",
-                                    mime='application/vnd.ms-excel'
-                                )
-                            elif export_format == "JSON":
-                                json_str = st.session_state.df.to_json(orient='records', indent=2)
-                                st.download_button(
-                                    label="Download JSON",
-                                    data=json_str,
-                                    file_name=f"{export_filename}.json",
-                                    mime='application/json'
-                                )
-                            st.success("Export ready!")
-                        except Exception as e:
-                            st.error(f"Export failed: {str(e)}")
-                
-        # Input area
-        input_method = st.radio("Input method:", ["Auto run code","Manual run code"])
-
-        user_input = st.text_area("Enter your Python code or question:", height=150,
-                                placeholder="Write code here or ask a question about your data...",
-                                key="user_input")
-        
-        
-
-        # Mode handling
-        if input_method == "Auto run code":
-            col1, col2, col3 = st.columns(3)
-            with col1: execute_btn = st.button("▶️ Execute")
-            with col2: clear_btn = st.button("🗑️ Clear History")
-            with col3: show_vars = st.button("📊 Show Variables")
-            # Common button handling
-            if clear_btn:
-                st.session_state.execution_history = []
-                
-            if show_vars and st.session_state.execution_history:
-                latest_vars = st.session_state.execution_history[-1].get('variables', {})
-                st.json({k: str(type(v)) for k, v in latest_vars.items()})
-            if execute_btn and user_input:
-                with st.spinner("Execute code..."):
-                    generated_code = code_llm(generate_prompt(user_input, st.session_state.df.columns.tolist()))
-                    st.markdown("**Generated Code:**")
-                    st.code(generated_code, language='python')
-                    
-                    result = execute_code(generated_code, st.session_state.df)
-                    add_to_history(result)
-                st.rerun()
-
-        elif input_method == "Manual run code":
-            col1, col2, col3, col4 = st.columns(4)
-            with col1: code_btn = st.button("▶️ Code")
-            with col2: execute_btn = st.button("▶️ Execute")
-            with col3: clear_btn = st.button("🗑️ Clear History")
-            with col4: show_vars = st.button("📊 Show Variables")
-
-            if clear_btn:
-                st.session_state.execution_history = []
-                
-            if show_vars and st.session_state.execution_history:
-                latest_vars = st.session_state.execution_history[-1].get('variables', {})
-                st.json({k: str(type(v)) for k, v in latest_vars.items()})
-
-            if code_btn and user_input:
-                with st.spinner("Generate Code"):
-                    generated_code = code_llm(generate_prompt(user_input, st.session_state.df.columns.tolist()))
-                    st.session_state.generated_code = generated_code
-                    st.markdown("**Generated Code:**")
-                    st.code(generated_code, language='python')
-            
-            if execute_btn:
-                if 'generated_code' in st.session_state:
-                    result = execute_code(st.session_state.generated_code, st.session_state.df)
-                    add_to_history(result)
-                elif user_input:
-                    result = execute_code(user_input, st.session_state.df)
-                    add_to_history(result)
-                st.rerun()
-                    
-        # Display execution history
+import io
+import streamlit as st
+import pandas as pd
+import csv
+import re
+import plotly.express as px
+from scipy.stats import skew
+from prompt_models import *
+from execution_programs import *
+from llm_models import text_llm, code_llm
+
+st.set_page_config(layout="wide")
+    
+# Custom style CSS
+st.markdown("""
+<style>
+    .block-container {
+        padding-top: 1rem;
+        padding-bottom: 1rem;
+        padding-left: 0rem;
+        padding-right: 0rem;
+    }
+    .element-container:has(.stColumn) {
+        gap: 0rem !important;
+    }
+    div[data-testid="column"] {
+        padding-left: 0rem !important;
+        padding-right: 0rem !important;
+    }
+    .stApp {
+        max-width: 1200px;
+        margin: 0 auto;
+        padding: 1rem;
+    }
+    .cell {
+        border: 1px solid #e0e0e0;
+        border-radius: 4px;
+        padding: 1rem;
+        margin-bottom: 1.5rem;
+        background-color: #f9f9f9;
+    }
+    .output {
+        border-left: 3px solid #4285f4;
+        padding-left: 1rem;
+        margin-top: 0.5rem;
+    }
+    .input-area {
+        background-color: #f5f5f5;
+        padding: 1rem;
+        border-radius: 4px;
+        margin-bottom: 1rem;
+    }
+    .stButton > button {
+        padding: 0rem 0.5rem; 
+        border-radius: 5px; 
+        font-size: 16px; 
+        font-weight: bold; 
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); 
+        transition: all 0.3s ease; 
+    }
+
+    .stButton > button:hover {
+        background-color: #357ae8; 
+        border-color: #357ae8; 
+        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15); 
+    }
+    .history-item {
+        margin-bottom: 2rem;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    .chat-message {
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+        display: flex;
+    }
+    .chat-message.user {
+        background-color: #262626;
+        align-self: flex-start;  
+    }
+    .chat-message.assistant {
+        background-color: #262626;
+        align-self: flex-end; 
+    }
+    .chat-message {
+            font-size: 14px; 
+    }
+    .chat-message.user {
+            font-size: 16px;  
+    }
+    .chat-message.assistant {
+            font-size: 14px; 
+    }
+    .sidebar {
+        width: 300px;
+        padding-right: 2rem;
+    }
+    .delete-btn {
+        background-color: #ff4b4b !important;
+        color: white !important;
+        border: none !important;
+        padding: 0.25rem 0.5rem !important;
+        font-size: 0.8rem !important;
+        margin-top: 0.5rem;
+    }
+    .delete-btn:hover {
+        background-color: #ff0000 !important;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'execution_history' not in st.session_state:
+    st.session_state.execution_history = []
+if 'df' not in st.session_state:
+    st.session_state.df = None
+
+
+# Main app layout
+col1a, col2a = st.columns([4, 7], gap="small")
+st.markdown("<div style='margin-top: 5px'></div>", unsafe_allow_html=True)
+show_col1 = st.toggle("Ask chat bot", value=True)
+
+if show_col1:
+    col1a, col2a = st.columns([4,7]) 
+else:
+    _ , col2a = st.columns([0.0001, 2]) 
+    
+with col1a:
+  if show_col1:
+    with st.container(height=570):
+        st.header("💬 Chatbot Assistant")
+        
+        # Initial state
+        if 'chatbot' not in st.session_state:
+            st.session_state.chatbot = {
+                'chat_history': [],
+                'prev_df': None,
+                'prev_raw_dataframes': None
+            }
+        
+        # button clear all chat
+        if st.button("🗑️ Clear all chat", key="clear_all_chat"):
+            st.session_state.chatbot['chat_history'] = []
+        
+        # show history chatbot
+        for i in range(0, len(st.session_state.chatbot['chat_history']), 2):
+            user_msg = st.session_state.chatbot['chat_history'][i]
+            assistant_msg = st.session_state.chatbot['chat_history'][i+1] if i+1 < len(st.session_state.chatbot['chat_history']) else None
+
+            with st.expander(f"Chat {i//2 + 1}", expanded=False):
+                with st.chat_message("user"):
+                    st.markdown(user_msg["content"])
+                if assistant_msg:
+                    with st.chat_message("assistant"):
+                        st.markdown(assistant_msg["content"])
+
+        
+        # Input chat
+        user_query = st.chat_input("Ask coding questions...", key="chatbot_input")
+
+        if user_query:
+            # save previous state
+            st.session_state.chatbot['prev_df'] = st.session_state.get('df')
+            st.session_state.chatbot['prev_raw_dataframes'] = st.session_state.get('raw_dataframes')
+            
+            # show chat user
+            with st.chat_message("user"):
+                st.markdown(user_query)
+            
+            # add to history chat
+            st.session_state.chatbot['chat_history'].append({"role": "user", "content": user_query})
+            
+            with st.spinner("Thinking..."):
+                if "df" in st.session_state:
+                    try:
+                        df = st.session_state.df
+                        columns = df.columns
+                        shape = df.shape
+                        dtypes = df.dtypes
+                        response = text_llm(prompt_chatbot(user_query,st.session_state.df.columns, st.session_state.df.shape, st.session_state.df.dtypes))
+                        clean_response = re.sub(r'<\s*think\s*>.*?<\s*/\s*think\s*>', '', response, flags=re.DOTALL | re.IGNORECASE)
+                        
+                        # show and save chatbot response
+                        with st.chat_message("assistant"):
+                            st.markdown(clean_response)
+                        st.session_state.chatbot['chat_history'].append({"role": "assistant", "content": clean_response})
+                    except AttributeError as e:
+                        st.error(f"Please confirm dataset before starting the chat: {e}")
+                else:
+                    st.write('You need to upload the data first')
+
+with col2a:  # Sidebar for chatbot
+    with st.container(height=570):
+        st.header("📊 DataCoder AI")
+        st.markdown("Analyze your CSV data with LLM Models")
+
+        def reset_data_state():
+            st.session_state.df = None
+            st.session_state.raw_dataframes = None
+            st.session_state.preview_df = None
+            st.session_state.file_names = [f.name for f in uploaded_files] if uploaded_files else []
+
+        # Initialize session state if not already present
+        if 'df' not in st.session_state:
+            st.session_state.df = None
+
+        uploaded_files = st.file_uploader(
+            "Upload CSV file(s)", 
+            type=["csv"], 
+            accept_multiple_files=True,
+            help="Upload one or more CSV files to combine"
+        )
+
+        if uploaded_files:
+            # Reset processing if files change
+            if 'prev_uploaded_files' not in st.session_state or st.session_state.prev_uploaded_files != [f.name for f in uploaded_files]:
+                st.session_state.df = None
+                st.session_state.raw_dataframes = None
+                st.session_state.preview_df = None
+                st.session_state.prev_uploaded_files = [f.name for f in uploaded_files]
+            
+            # Process files but don't merge yet
+            if st.session_state.raw_dataframes is None:
+                dataframes = []
+                processed_files = 0
+                
+                for uploaded_file in uploaded_files:
+                    with st.expander(f"📄 File: {uploaded_file.name}", expanded=False):
+                        try:
+                            # Try to detect delimiter
+                            raw_data = uploaded_file.getvalue().decode("utf-8")
+                            sniffer = csv.Sniffer()
+                            
+                            try:
+                                dialect = sniffer.sniff(raw_data.splitlines()[0])
+                                delimiter = dialect.delimiter
+                            except (csv.Error, IndexError):
+                                # Try common delimiters if sniffing fails
+                                for test_delim in [',', ';', '\t', '|']:
+                                    if test_delim in raw_data:
+                                        delimiter = test_delim
+                                        break
+                                else:
+                                    delimiter = ','  # default
+                            
+                            uploaded_file.seek(0)  # Reset file pointer
+                            
+                            # Read CSV with error handling
+                            try:
+                                df = pd.read_csv(uploaded_file, delimiter=delimiter, on_bad_lines='warn')
+                            except Exception as e:
+                                st.warning(f"Using Python engine for {uploaded_file.name} due to parsing issues")
+                                df = pd.read_csv(uploaded_file, delimiter=delimiter, engine='python')
+                            
+                            # Display file info
+                            st.write(f"Shape: {df.shape}")
+                            st.write(f"Detected delimiter: '{delimiter}'")
+                            st.dataframe(df.head(5), use_container_width=True)
+                            
+                            dataframes.append(df)
+                            processed_files += 1
+                            
+                        except Exception as e:
+                            st.error(f"Error processing {uploaded_file.name}: {str(e)}")
+                            continue
+                
+                if processed_files == 0:
+                    st.error("No files were successfully processed")
+                    st.stop()
+                
+                # Store raw dataframes in session state
+                st.session_state.raw_dataframes = dataframes
+            
+            # Only proceed if we have raw dataframes
+            if st.session_state.raw_dataframes:
+                dataframes = st.session_state.raw_dataframes
+                
+                col1, col2 = st.columns([3, 1])
+                
+                with col1:
+                    merge_option = st.radio(
+                        "Merge method:",
+                        ("single data","Horizontal (concat columns)", "Vertical (concat rows)", "Horizontal (merge on common columns)"),
+                        index=0,
+                        horizontal=True,
+                        key="merge_option"
+                    )
+                    
+                    # Additional merge parameters
+                    if merge_option == "Horizontal (merge on common columns)":
+                        if len(dataframes) > 0:
+                            common_cols = set(dataframes[0].columns)
+                            for df in dataframes[1:]:
+                                common_cols.intersection_update(df.columns)
+                            
+                            if common_cols:
+                                selected_cols = st.multiselect(
+                                    "Select columns to merge on:",
+                                    options=list(common_cols),
+                                    default=list(common_cols),
+                                    key="merge_columns"
+                                )
+                                how_merge = st.selectbox(
+                                    "Merge type:",
+                                    ["inner", "outer", "left", "right"],
+                                    index=1,
+                                    key="how_merge"
+                                )
+                            else:
+                                None
+                
+                with col2:
+                    preview_button = st.button("🔄 Preview")
+                    confirm_button = st.button("✅ Confirm")
+                    reset_btn = st.button("🔄 Reset")
+                
+                # Reset logic
+                if reset_btn:
+                    reset_data_state()
+                    st.rerun()
+                
+                # Preview logic
+                if preview_button:
+                    with st.spinner("Generating preview..."):
+                        try:
+                            if merge_option == "single data":
+                                preview_df = dataframes[0]
+                            elif merge_option == "Horizontal (concat columns)":
+                                # Find common indices across ALL dataframes
+                                common_indices = dataframes[0].index
+                                for df in dataframes[1:]:
+                                    common_indices = common_indices.intersection(df.index)
+                                
+                                if len(common_indices) == 0:
+                                    st.error("No common indices found across all dataframes")
+                                    st.stop()
+                                
+                                # Filter all dataframes to only common indices
+                                filtered_dfs = [df.loc[common_indices] for df in dataframes]
+                                
+                                # Handle duplicate column names
+                                all_columns = []
+                                duplicate_counter = {}
+                                
+                                for i, df in enumerate(filtered_dfs):
+                                    new_columns = []
+                                    for col in df.columns:
+                                        if col in all_columns:
+                                            if col not in duplicate_counter:
+                                                duplicate_counter[col] = 1
+                                            duplicate_counter[col] += 1
+                                            new_col = f"{col}_df{duplicate_counter[col]}"
+                                            new_columns.append(new_col)
+                                        else:
+                                            new_columns.append(col)
+                                    all_columns.extend(new_columns)
+                                    filtered_dfs[i].columns = new_columns
+                                
+                                # Concatenate horizontally
+                                preview_df = pd.concat(filtered_dfs, axis=1)
+                                
+                            elif merge_option == "Vertical (concat rows)":
+                                preview_df = pd.concat(dataframes, axis=0, ignore_index=True)
+                                
+                            elif merge_option == "Horizontal (merge on common columns)":
+                                def auto_merge_many(dfs):
+                                    if not dfs:
+                                        return None
+                                    
+                                    merged_df = dfs[0]
+                                    
+                                    for next_df in dfs[1:]:
+                                        common_keys = list(set(merged_df.columns) & set(next_df.columns))
+                                        if common_keys:
+                                            merged_df = pd.merge(merged_df, next_df, on=common_keys)
+                                        else:
+                                            print(f"[WARNING] There is no matching key between:\n{merged_df.columns}\n&\n{next_df.columns}")
+                                    
+                                    return merged_df
+                                
+                                preview_df = auto_merge_many(dataframes)
+                            
+                            st.session_state.preview_df = preview_df
+                            st.success("Preview generated!")
+                            
+                            # Show preview stats
+                            st.subheader("Preview Results")
+                            st.write(f"Shape: {preview_df.shape}")
+                            
+                            # Show sample data with tabs
+                            tab1, tab2 = st.tabs(["First Rows", "Last Rows"])
+                            with tab1:
+                                st.dataframe(preview_df.head(20), use_container_width=True)
+                            with tab2:
+                                st.dataframe(preview_df.tail(20), use_container_width=True)
+                            
+                            # Show quick stats
+                            with st.expander("Preview Statistics"):
+                                st.write("Column types:")
+                                st.dataframe(preview_df.dtypes.astype(str).reset_index().rename(
+                                    columns={'index': 'Column', 0: 'DataType'}
+                                ))
+                                
+                                st.write("Missing values:")
+                                missing = preview_df.isnull().sum()
+                                missing = missing[missing > 0].reset_index().rename(
+                                    columns={'index': 'Column', 0: 'Missing Count'}
+                                )
+                                if len(missing) > 0:
+                                    st.dataframe(missing)
+                                else:
+                                    st.success("No missing values found!")
+                        
+                        except Exception as e:
+                            st.error(f"Preview failed: {str(e)}")
+                            st.stop()
+                
+                # Confirm merge logic
+                if confirm_button and st.session_state.preview_df is not None:
+                    st.session_state.df = st.session_state.preview_df
+                    st.session_state.preview_df = None  # Clear preview after confirmation
+                    st.success("Data is now available for analysis.")
+                    st.balloons()
+                    st.rerun()
+                
+                # Show raw data info
+                with st.expander("📦 Raw Data Summary", expanded=False):
+                    st.write(f"Total files loaded: {len(dataframes)}")
+                    for i, df in enumerate(dataframes, 1):
+                        st.write(f"### Dataframe {i}")
+                        st.write(f"- Shape: {df.shape}")
+                        st.write("- Columns:")
+                        st.dataframe(pd.DataFrame({
+                            'Column': df.columns,
+                            'Type': df.dtypes.values,
+                            'Missing %': (df.isnull().mean() * 100).round(2)
+                        }), hide_index=True)
+                        
+                        if st.checkbox(f"Show sample data for Dataframe {i}", key=f"show_raw_{i}"):
+                            st.dataframe(df.head(5), use_container_width=True)
+            
+            # If merge is already confirmed, show the final data
+            if st.session_state.df is not None:
+                
+                # Data cleaning options (only after merge is confirmed)
+                with st.expander("**🧹 Data Cleaning**", expanded=True):
+                    # Inisialisasi df_cleaned di session state jika belum ada
+
+                    st.session_state.df_cleaned = st.session_state.df.copy()
+                    
+                    clean_options = st.columns(4)
+                    
+                    with clean_options[0]:
+                        clean_nan = st.selectbox(
+                            "Handle NaN values:",
+                            ["Keep", "Remove rows", "Fill with zero", "Fill with mean"],
+                            index=0,
+                            key="clean_nan"
+                        )
+                        
+                        if st.button("Apply NaN Handling"):
+                            if clean_nan == "Fill with zero":
+                                st.session_state.df_cleaned = st.session_state.df_cleaned.fillna(0)
+                                st.success("Filled NaN with zeros!")
+                            elif clean_nan == "Fill with mean":
+                                st.session_state.df_cleaned = st.session_state.df_cleaned.fillna(st.session_state.df_cleaned.mean())
+                                st.success("Filled NaN with mean values!")
+                            elif clean_nan == "Remove rows":
+                                initial_rows = len(st.session_state.df_cleaned)
+                                st.session_state.df_cleaned = st.session_state.df_cleaned.dropna()
+                                removed_nan = initial_rows - len(st.session_state.df_cleaned)
+                                st.success(f"Removed {removed_nan} rows with NaN values!")
+                    
+                    with clean_options[1]:
+                        clean_duplicates = st.selectbox(
+                            "Handle duplicates:",
+                            ["Keep", "Remove all", "Keep first", "Keep last"],
+                            index=0,
+                            key="clean_duplicates"
+                        )
+                        
+                        if st.button("Apply Deduplication"):
+                            if clean_duplicates != "Keep":
+                                initial_rows = len(st.session_state.df_cleaned)
+                                if clean_duplicates == "Remove all":
+                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop_duplicates(keep=False)
+                                elif clean_duplicates == "Keep first":
+                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop_duplicates(keep='first')
+                                elif clean_duplicates == "Keep last":
+                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop_duplicates(keep='last')
+                                
+                                removed_dups = initial_rows - len(st.session_state.df_cleaned)
+                                st.success(f"Removed {removed_dups} duplicate rows!")
+                    
+                    with clean_options[2]:
+                        col_rename = st.text_input("Rename ('old:new')")
+                        if st.button("Rename Column") and col_rename and ":" in col_rename:
+                            old, new = col_rename.split(":", 1)
+                            if old in st.session_state.df_cleaned.columns:
+                                st.session_state.df_cleaned = st.session_state.df_cleaned.rename(columns={old: new})
+                                st.success(f"Renamed column '{old}' to '{new}'")
+                            else:
+                                st.warning(f"Column '{old}' not found")
+                                
+                    with clean_options[3]:
+                        # Fitur Drop Columns
+                        cols_to_drop = st.text_input(
+                            "Drop columns", 
+                            placeholder="column1, column2, ...",
+                            key="drop_cols_input"
+                        )
+                        
+                        if st.button("Drop Columns"):
+                            if cols_to_drop:
+                                # Proses input: hilangkan spasi, split by comma, dan bersihkan
+                                columns_list = [col.strip() for col in cols_to_drop.split(",") if col.strip()]
+                                
+                                # Fungsi untuk mencocokkan nama kolom dengan fleksibilitas
+                                def find_matching_column(col_name, df_columns):
+                                    col_name = col_name.lower().strip()
+                                    for df_col in df_columns:
+                                        if df_col.lower().strip() == col_name:
+                                            return df_col
+                                    return None
+                                
+                                # Cari kolom yang cocok
+                                matched_cols = []
+                                not_found = []
+                                
+                                for col in columns_list:
+                                    matched = find_matching_column(col, st.session_state.df_cleaned.columns)
+                                    if matched:
+                                        matched_cols.append(matched)
+                                    else:
+                                        not_found.append(col)
+                                
+                                # Drop kolom yang ditemukan
+                                if matched_cols:
+                                    initial_cols = st.session_state.df_cleaned.columns.tolist()
+                                    st.session_state.df_cleaned = st.session_state.df_cleaned.drop(columns=matched_cols)
+                                    st.success(f"Successfully dropped columns: {', '.join(matched_cols)}")
+                                    
+                                    # Tampilkan warning untuk kolom yang tidak ditemukan
+                                    if not_found:
+                                        st.warning(f"Columns not found: {', '.join(not_found)}")
+                                    
+                                    # Tampilkan perubahan
+                                    st.write(f"Remaining columns: {len(st.session_state.df_cleaned.columns)}")
+                                else:
+                                    st.error("No matching columns found to drop")
+                            else:
+                                st.warning("Please enter column names to drop")
+
+                    # Tampilkan info missing values setelah cleaning
+                    missing_values = st.session_state.df_cleaned.isnull().sum().sum()
+                    duplicate_values = st.session_state.df_cleaned.duplicated().sum().sum()
+                    if missing_values > 0 or duplicate_values > 0:
+                        st.warning(f"⚠️ Warning: There are still {missing_values} missing values and {duplicate_values} ducplicate rows in the data")
+                    else:
+                        st.success("✅ No missing values and duplicate rows remaining!")
+                
+                # Final data display
+                st.session_state.df = st.session_state.df_cleaned
+                st.subheader("📊 Final Data")
+                st.write(f"Shape: {st.session_state.df.shape}")
+                
+                # Interactive data explorer
+                tab1, tab2, tab3, tab4 = st.tabs(["Data View", "Statistics", "Column Analysis", 'Type Data'])
+                
+                with tab1:
+                    num_rows = st.slider(
+                        "Number of rows to display:",
+                        min_value=5,
+                        max_value=100,
+                        value=5,
+                        key="num_rows_view"
+                    )
+                    st.dataframe(st.session_state.df.head(num_rows), use_container_width=True)
+                
+                with tab2:
+                    st.write("### Descriptive Statistics")
+                    st.dataframe(st.session_state.df.describe(include='all'), use_container_width=True)
+                    
+                
+                with tab3:
+                    selected_col = st.selectbox(
+                        "Select column to analyze:",
+                        st.session_state.df.columns,
+                        key="col_analyze"
+                    )
+                    
+                    col_data = st.session_state.df[selected_col]
+                    st.write(f"**Type:** {col_data.dtype}")
+                    st.write(f"**Unique values:** {len(col_data.unique())}")
+                    st.write(f"**Missing values:** {col_data.isnull().sum()} ({col_data.isnull().mean()*100:.2f}%)")
+                    
+
+                    if col_data.nunique() < 20 and not pd.api.types.is_numeric_dtype(col_data):
+                        ascending = st.checkbox("Ascending", value=False)
+                        st.write("**Distribution**")
+                        column_name = col_data.name
+
+                        # sum and sort data
+                        counts = col_data.value_counts(ascending=ascending)
+                        ordered_categories = counts.index.tolist()
+
+                        # create dataframe and category for data
+                        df_temp = pd.DataFrame({column_name: col_data})
+                        df_temp[column_name] = pd.Categorical(df_temp[column_name], categories=ordered_categories, ordered=True)
+
+                        # create histogram
+                        fig = px.histogram(
+                            df_temp,
+                            x=column_name,
+                            opacity=0.7,
+                            color_discrete_sequence=["#d06200"],
+                        )
+
+                        fig.update_traces(marker_line_color='gray', marker_line_width=1)
+
+                        # Show x axis based on category sorting
+                        fig.update_layout(
+                            template='seaborn',
+                            title=f"Histogram of {column_name}",
+                            xaxis_title=column_name,
+                            yaxis_title="Count",
+                            bargap=0.1,
+                            font=dict(family="Verdana", size=13),
+                            xaxis=dict(
+                                categoryorder="array",
+                                categoryarray=ordered_categories,
+                            )
+                        )
+
+                        st.plotly_chart(fig, use_container_width=True)
+
+                    elif pd.api.types.is_numeric_dtype(col_data):
+                        st.write("**Distribution**")
+                        column_name = col_data.name
+
+                        df_temp = pd.DataFrame({column_name: col_data.dropna()})
+                        
+                        fig = px.histogram(
+                            df_temp,
+                            x=column_name,
+                            nbins=30,
+                            opacity=0.85,
+                            color_discrete_sequence=["#d06200"],
+                        )
+
+                        fig.update_traces(marker_line_color='gray', marker_line_width=0.9)
+
+                        fig.update_layout(
+                            template='seaborn',
+                            title=f"Histogram of {column_name}",
+                            xaxis_title=column_name,
+                            yaxis_title="Count",
+                            bargap=0.1,
+                            font=dict(family="Verdana", size=13),
+                        )
+                        fig.update_layout(
+                            annotations=[
+                                dict(
+                                    text=f"Skewness: {skew(col_data):.2f}",
+                                    showarrow=False,
+                                    xref="paper", yref="paper",
+                                    x=0.95, y=0.95,
+                                    bordercolor='black',
+                                    borderwidth=1
+                                )
+                            ]
+                        )
+
+                        st.plotly_chart(fig, use_container_width=True)
+
+                    else:
+                        st.write("**Value counts (top 20):**")
+                        st.dataframe(col_data.value_counts().head(20))
+
+
+                with tab4:
+                    buffer = io.StringIO()
+                    st.session_state.df.info(buf=buffer)
+                    st.text(buffer.getvalue())
+
+                    st.markdown("**Data Types:**")
+                    st.json(st.session_state.df.dtypes.astype(str).to_dict())
+
+                    st.markdown("**Missing Values:**")
+                    st.json(st.session_state.df.isnull().sum().to_dict())
+
+                    st.markdown("**Duplicate:**")
+                    duplicate_count = st.session_state.df.duplicated().sum()
+                    st.write(f"Total duplicate row: {duplicate_count}")
+
+                    # Menampilkan jumlah duplikat dalam format JSON yang benar
+                    st.json({"duplicate_count": duplicate_count})
+
+                
+                # Export options
+                with st.expander("💾 Export Data", expanded=False):
+                    export_format = st.radio(
+                        "Export format:",
+                        ["CSV", "Excel", "JSON"],
+                        horizontal=True
+                    )
+                    
+                    export_filename = st.text_input("Filename (without extension)", "clean_data")
+                    
+                    if st.button("Export Data"):
+                        try:
+                            if export_format == "CSV":
+                                csv = st.session_state.df.to_csv(index=False).encode('utf-8')
+                                st.download_button(
+                                    label="Download CSV",
+                                    data=csv,
+                                    file_name=f"{export_filename}.csv",
+                                    mime='text/csv'
+                                )
+                            elif export_format == "Excel":
+                                excel_buffer = io.BytesIO()
+                                st.session_state.df.to_excel(excel_buffer, index=False)
+                                st.download_button(
+                                    label="Download Excel",
+                                    data=excel_buffer,
+                                    file_name=f"{export_filename}.xlsx",
+                                    mime='application/vnd.ms-excel'
+                                )
+                            elif export_format == "JSON":
+                                json_str = st.session_state.df.to_json(orient='records', indent=2)
+                                st.download_button(
+                                    label="Download JSON",
+                                    data=json_str,
+                                    file_name=f"{export_filename}.json",
+                                    mime='application/json'
+                                )
+                            st.success("Export ready!")
+                        except Exception as e:
+                            st.error(f"Export failed: {str(e)}")
+                
+        # Input area
+        input_method = st.radio("Input method:", ["Auto run code","Manual run code"])
+
+        user_input = st.text_area("Enter your Python code or question:", height=150,
+                                placeholder="Write code here or ask a question about your data...",
+                                key="user_input")
+        
+        
+
+        # Mode handling
+        if input_method == "Auto run code":
+            col1, col2, col3 = st.columns(3)
+            with col1: execute_btn = st.button("▶️ Execute")
+            with col2: clear_btn = st.button("🗑️ Clear History")
+            with col3: show_vars = st.button("📊 Show Variables")
+            # Common button handling
+            if clear_btn:
+                st.session_state.execution_history = []
+                
+            if show_vars and st.session_state.execution_history:
+                latest_vars = st.session_state.execution_history[-1].get('variables', {})
+                st.json({k: str(type(v)) for k, v in latest_vars.items()})
+            if execute_btn and user_input:
+                with st.spinner("Execute code..."):
+                    generated_code = code_llm(generate_prompt(user_input, st.session_state.df.columns.tolist()))
+                    st.markdown("**Generated Code:**")
+                    st.code(generated_code, language='python')
+                    
+                    result = execute_code(generated_code, st.session_state.df)
+                    add_to_history(result)
+                st.rerun()
+
+        elif input_method == "Manual run code":
+            col1, col2, col3, col4 = st.columns(4)
+            with col1: code_btn = st.button("▶️ Code")
+            with col2: execute_btn = st.button("▶️ Execute")
+            with col3: clear_btn = st.button("🗑️ Clear History")
+            with col4: show_vars = st.button("📊 Show Variables")
+
+            if clear_btn:
+                st.session_state.execution_history = []
+                
+            if show_vars and st.session_state.execution_history:
+                latest_vars = st.session_state.execution_history[-1].get('variables', {})
+                st.json({k: str(type(v)) for k, v in latest_vars.items()})
+
+            if code_btn and user_input:
+                with st.spinner("Generate Code"):
+                    generated_code = code_llm(generate_prompt(user_input, st.session_state.df.columns.tolist()))
+                    st.session_state.generated_code = generated_code
+                    st.markdown("**Generated Code:**")
+                    st.code(generated_code, language='python')
+            
+            if execute_btn:
+                if 'generated_code' in st.session_state:
+                    result = execute_code(st.session_state.generated_code, st.session_state.df)
+                    add_to_history(result)
+                elif user_input:
+                    result = execute_code(user_input, st.session_state.df)
+                    add_to_history(result)
+                st.rerun()
+                    
+        # Display execution history
         display_history()