Update app.py

app.py

@@ -1,72 +1,214 @@
 import streamlit as st
-import requests
-import folium
-from streamlit_folium import st_folium
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from scipy import stats
+import statsmodels.api as sm
+from datetime import datetime
 
-# تنظیم کلیدهای API
-MAP_API_KEY = "6y94o8MigcYbmaCI6IlVQGtmza5tzKri"
-POINT_API_KEY = "n5IyYjKAA0IgOZ7cNEleGtkWg4fJLBil"
+st.set_page_config(page_title="Excel Analysis Suite", layout="wide")
 
-# تنظیم موقعیت جغرافیایی
-DEFAULT_LAT = 31.534442
-DEFAULT_LON = 48.724416
+def load_data(file):
+    if file.name.endswith('.xlsx') or file.name.endswith('.xls'):
+        df = pd.read_excel(file)
+    else:
+        df = pd.read_csv(file)  # Fallback to CSV
+    return df
 
-# اضافه کردن فایل CSS برای استایل‌دهی
-def local_css(file_name):
-    with open(file_name) as f:
-        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+def get_column_type(column):
+    if pd.api.types.is_numeric_dtype(column):
+        return "numeric"
+    elif pd.api.types.is_datetime64_any_dtype(column):
+        return "datetime"
+    else:
+        return "categorical"
 
-local_css("style.css")
+def main():
+    st.title("📊 Excel Analysis Suite")
+    
+    # File Upload
+    uploaded_file = st.file_uploader(
+        "Drop Excel File Here (.xlsx, .xls, .csv)", 
+        type=['xlsx', 'xls', 'csv']
+    )
+    
+    if uploaded_file:
+        # File Metadata
+        st.sidebar.header("File Information")
+        st.sidebar.write(f"📄 Name: {uploaded_file.name}")
+        st.sidebar.write(f"📏 Size: {uploaded_file.size / 1024:.2f} KB")
+        
+        # Load Data
+        df = load_data(uploaded_file)
+        st.sidebar.write(f"📊 Dimensions: {df.shape[0]} rows × {df.shape[1]} columns")
+        
+        # Data Preview
+        st.subheader("Data Preview")
+        st.dataframe(df.head(10), use_container_width=True)
+        
+        # Column Selection
+        st.sidebar.header("Column Selection")
+        column_types = {col: get_column_type(df[col]) for col in df.columns}
+        selected_columns = st.sidebar.multiselect(
+            "Select columns for analysis",
+            df.columns,
+            default=df.select_dtypes(include=[np.number]).columns.tolist()[:2]
+        )
+        
+        # Analysis Type Selection
+        analysis_type = st.radio(
+            "Choose Analysis Type",
+            ["Statistical Analysis", "Predictive Modeling", "Time Series Analysis"],
+            horizontal=True
+        )
+        
+        if analysis_type == "Statistical Analysis":
+            st.subheader("Statistical Analysis")
+            
+            if len(selected_columns) >= 2:
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.write("### Correlation Analysis")
+                    corr_matrix = df[selected_columns].corr()
+                    fig = px.imshow(
+                        corr_matrix,
+                        color_continuous_scale='RdBu',
+                        aspect='auto'
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+                
+                with col2:
+                    st.write("### Summary Statistics")
+                    st.dataframe(df[selected_columns].describe(), use_container_width=True)
+                
+                # ANOVA Analysis for categorical vs numeric
+                numeric_cols = [col for col in selected_columns if column_types[col] == "numeric"]
+                categorical_cols = [col for col in selected_columns if column_types[col] == "categorical"]
+                
+                if numeric_cols and categorical_cols:
+                    st.write("### ANOVA Analysis")
+                    target = st.selectbox("Select numeric variable", numeric_cols)
+                    factor = st.selectbox("Select categorical variable", categorical_cols)
+                    
+                    groups = [group for _, group in df.groupby(factor)[target]]
+                    f_stat, p_val = stats.f_oneway(*groups)
+                    st.write(f"F-statistic: {f_stat:.4f}")
+                    st.write(f"p-value: {p_val:.4f}")
+                    
+                    fig = px.box(df, x=factor, y=target)
+                    st.plotly_chart(fig, use_container_width=True)
+        
+        elif analysis_type == "Predictive Modeling":
+            st.subheader("Predictive Modeling")
+            
+            numeric_cols = [col for col in df.columns if column_types[col] == "numeric"]
+            if len(numeric_cols) >= 2:
+                target = st.selectbox("Select target variable", numeric_cols)
+                features = st.multiselect(
+                    "Select feature variables",
+                    [col for col in numeric_cols if col != target],
+                    default=[col for col in numeric_cols if col != target][:2]
+                )
+                
+                if features:
+                    test_size = st.slider("Test set size (%)", 10, 40, 20) / 100
+                    
+                    X = df[features]
+                    y = df[target]
+                    
+                    X_train, X_test, y_train, y_test = train_test_split(
+                        X, y, test_size=test_size, random_state=42
+                    )
+                    
+                    model = RandomForestRegressor(n_estimators=100, random_state=42)
+                    model.fit(X_train, y_train)
+                    
+                    y_pred = model.predict(X_test)
+                    r2_score = model.score(X_test, y_test)
+                    
+                    st.write(f"R² Score: {r2_score:.4f}")
+                    
+                    fig = px.scatter(
+                        x=y_test, y=y_pred,
+                        labels={'x': 'Actual', 'y': 'Predicted'},
+                        title='Actual vs Predicted Values'
+                    )
+                    fig.add_trace(
+                        go.Scatter(
+                            x=[y_test.min(), y_test.max()],
+                            y=[y_test.min(), y_test.max()],
+                            mode='lines',
+                            name='Perfect Prediction',
+                            line=dict(dash='dash')
+                        )
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+                    
+                    # Feature Importance
+                    importance_df = pd.DataFrame({
+                        'Feature': features,
+                        'Importance': model.feature_importances_
+                    }).sort_values('Importance', ascending=True)
+                    
+                    fig = px.bar(
+                        importance_df,
+                        x='Importance',
+                        y='Feature',
+                        orientation='h',
+                        title='Feature Importance'
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+        
+        elif analysis_type == "Time Series Analysis":
+            st.subheader("Time Series Analysis")
+            
+            date_cols = [col for col in df.columns if column_types[col] == "datetime"]
+            numeric_cols = [col for col in df.columns if column_types[col] == "numeric"]
+            
+            if date_cols and numeric_cols:
+                date_col = st.selectbox("Select date column", date_cols)
+                value_col = st.selectbox("Select value column", numeric_cols)
+                
+                # Resample data to daily frequency
+                df_ts = df.set_index(date_col)[[value_col]].resample('D').mean()
+                
+                # Plot time series
+                fig = px.line(
+                    df_ts,
+                    title=f'{value_col} Over Time',
+                    labels={'value': value_col, 'index': 'Date'}
+                )
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # Decompose time series
+                decomposition = sm.tsa.seasonal_decompose(
+                    df_ts[value_col].fillna(method='ffill'),
+                    period=30
+                )
+                
+                fig = go.Figure()
+                fig.add_trace(go.Scatter(
+                    x=decomposition.trend.index,
+                    y=decomposition.trend.values,
+                    name='Trend'
+                ))
+                fig.add_trace(go.Scatter(
+                    x=decomposition.seasonal.index,
+                    y=decomposition.seasonal.values,
+                    name='Seasonal'
+                ))
+                fig.add_trace(go.Scatter(
+                    x=decomposition.resid.index,
+                    y=decomposition.resid.values,
+                    name='Residual'
+                ))
+                fig.update_layout(title='Time Series Decomposition')
+                st.plotly_chart(fig, use_container_width=True)
 
-# تنظیمات اصلی
-st.markdown("<h1 style='text-align: center; color: #4CAF50;'>برنامه پیش‌بینی آب‌وهوا</h1>", unsafe_allow_html=True)
-st.sidebar.title("تنظیمات")
-selected_date = st.sidebar.date_input("تاریخ پیش‌بینی:")
-selected_time = st.sidebar.time_input("زمان پیش‌بینی:")
-
-st.markdown("<h3>موقعیت: شرکت دهخدا</h3>", unsafe_allow_html=True)
-
-# درخواست داده‌ها از API
-def get_weather_data(lat, lon):
-    url = f"https://api.windy.com/api/point-forecast/v2"
-    headers = {"Authorization": POINT_API_KEY}
-    params = {
-        "lat": lat,
-        "lon": lon,
-        "model": "gfs",
-        "parameters": ["windSpeed", "windDirection", "temperature", "precipitation"],
-        "levels": ["surface"],
-        "key": 6y94o8MigcYbmaCI6IlVQGtmza5tzKri,
-    }
-    response = requests.get(url, headers=headers, params=params)
-    return response.json() if response.status_code == 200 else None
-
-# دریافت داده‌ها
-weather_data = get_weather_data(DEFAULT_LAT, DEFAULT_LON)
-
-if weather_data:
-    st.markdown("<h3 style='color: #007BFF;'>اطلاعات آب‌وهوا</h3>", unsafe_allow_html=True)
-    st.write(f"🌬️ **سرعت باد:** {weather_data['windSpeed']} متر بر ثانیه")
-    st.write(f"🧭 **جهت باد:** {weather_data['windDirection']} درجه")
-    st.write(f"🌡️ **دمای هوا:** {weather_data['temperature']} °C")
-    st.write(f"🌧️ **بارش:** {weather_data['precipitation']} میلی‌متر")
-else:
-    st.error("مشکلی در دریافت اطلاعات آب‌وهوا وجود دارد.")
-
-# نمایش نقشه
-m = folium.Map(location=[DEFAULT_LAT, DEFAULT_LON], zoom_start=10)
-folium.Marker([DEFAULT_LAT, DEFAULT_LON], tooltip="شرکت دهخدا").add_to(m)
-st_folium(m, width=700, height=500)
-
-# پیش‌بینی انتشار دود
-def calculate_fire_spread(wind_speed, wind_direction):
-    spread_distance = wind_speed * 3 * 60 * 60  # سه ساعت
-    spread_lat = DEFAULT_LAT + (spread_distance / 111000) * wind_direction
-    spread_lon = DEFAULT_LON + (spread_distance / (111000 * abs(wind_direction)))
-    return spread_lat, spread_lon
-
-if weather_data:
-    st.markdown("<h3 style='color: #FF5722;'>پیش‌بینی انتشار دود</h3>", unsafe_allow_html=True)
-    lat, lon = calculate_fire_spread(weather_data['windSpeed'], weather_data['windDirection'])
-    st.write(f"🔺 دود در سه ساعت آینده به موقعیت زیر می‌رسد:")
-    st.write(f"📍 Latitude: {lat:.6f}, Longitude: {lon:.6f}")
+if __name__ == "__main__":
+    main()