Spaces:
Build error
Build error
| 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 | |
| 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() |