Update app.py

app.py

@@ -3,220 +3,331 @@ import pandas as pd
 import numpy as np
 import plotly.express as px
 from sklearn.ensemble import IsolationForest
-import io
-from fpdf import FPDF
-import requests
-import PyPDF2
-import tempfile
-import os
-
-# -------------------------------
-# Page Configuration and Header
-# -------------------------------
-st.set_page_config(page_title="🚀 WiFi Anomaly Detection", layout="wide")
-st.title("🚀 WiFi Anomaly Detection System")
-st.markdown("""
-> "Innovation distinguishes between a leader and a follower." – *Steve Jobs*
+from io import BytesIO
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.lib import colors
+import pdfplumber
+import base64
+import random
+import plotly.io as pio
+
+# Fix for Kaleido
+pio.kaleido.scope.mathjax = None
 
-> "The future depends on what you do today." – *Mahatma Gandhi*
-""")
+# App Configuration
+st.set_page_config(
+    page_title="WiFi Guardian 🛡️",
+    page_icon="📶",
+    layout="wide"
+)
+
+# Custom CSS for a polished interface
 st.markdown("""
-Welcome to the WiFi Anomaly Detection System. This application uses AI to proactively detect abnormal behavior in Public Wi-Fi systems, identifying suspicious spikes that may indicate hacking attempts. Let’s build a more secure network, one anomaly at a time!
-""")
-
-# -------------------------------
-# Define Helper Functions
-# -------------------------------
-def load_data(uploaded_file):
-    file_type = uploaded_file.name.split('.')[-1].lower()
-    if file_type == 'csv':
-        try:
-            df = pd.read_csv(uploaded_file)
-            return df, "csv"
-        except Exception as e:
-            st.error("Error reading CSV file.")
-            return None, None
-    elif file_type == 'txt':
-        try:
-            try:
-                df = pd.read_csv(uploaded_file, sep=",")
-            except:
-                df = pd.read_csv(uploaded_file, sep="\s+")
-            return df, "txt"
-        except Exception as e:
-            st.error("Error reading TXT file.")
-            return None, None
-    elif file_type == 'pdf':
+<style>
+    .st-emotion-cache-1kyxreq {
+        display: flex;
+        flex-flow: wrap;
+        gap: 2rem;
+    }
+    .reportview-container .main .block-container{
+        padding-top: 2rem;
+    }
+    .sidebar .sidebar-content {
+        background: linear-gradient(180deg, #2e3b4e, #1a2639);
+    }
+    .stButton>button {
+        width: 100%;
+        margin: 5px 0;
+        transition: all 0.3s;
+    }
+    .stButton>button:hover {
+        transform: scale(1.05);
+    }
+    .summary-box {
+        padding: 20px;
+        border-radius: 10px;
+        background-color: #2e3b4e;
+        margin: 10px 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Motivational Quotes
+QUOTES = [
+    "🛡️ Cybersecurity is not a product, but a process!",
+    "🔒 Better safe than hacked!",
+    "📶 A secure network is a happy network!",
+    "🤖 AI guards while you sleep!",
+    "🚨 Detect before you regret!",
+    "💻 Security is always worth the investment!",
+    "🔍 Stay vigilant, stay secure!"
+]
+
+def show_quote():
+    st.markdown(f"<h3 style='text-align: center; color: #4CAF50;'>{random.choice(QUOTES)}</h3>", 
+                unsafe_allow_html=True)
+
+# Main App Function
+def main():
+    # Initialize session state variables
+    if 'current_step' not in st.session_state:
+        st.session_state.current_step = 1
+    if 'file_uploaded' not in st.session_state:
+        st.session_state.file_uploaded = False
+    if 'df' not in st.session_state:
+        st.session_state.df = None
+
+    # Sidebar Navigation
+    with st.sidebar:
+        st.title("🔍 Navigation")
+        st.markdown("---")
+        
+        if st.button("📤 1. Upload File", help="Upload your network logs"):
+            st.session_state.current_step = 1
+        if st.button("📊 2. Data Visualization", disabled=not st.session_state.file_uploaded):
+            st.session_state.current_step = 2
+        if st.button("📈 3. Statistics Analysis", disabled=not st.session_state.file_uploaded):
+            st.session_state.current_step = 3
+        if st.button("📥 4. Download Report", disabled=not st.session_state.file_uploaded):
+            st.session_state.current_step = 4
+
+    # Main Content Area
+    if st.session_state.current_step == 1:
+        upload_file_section()
+    elif st.session_state.current_step == 2:
+        visualization_section()
+    elif st.session_state.current_step == 3:
+        statistics_section()
+    elif st.session_state.current_step == 4:
+        download_section()
+
+def upload_file_section():
+    st.title("📤 Upload Network Logs")
+    st.markdown("---")
+    
+    if not st.session_state.file_uploaded:
+        show_quote()
+        st.markdown("""
+        ### Welcome to WiFi Guardian! 🤖
+        **Protect your network with AI-powered anomaly detection**
+        1. Upload network logs 📤
+        2. Visualize patterns 📊
+        3. Generate reports 📄
+        """)
+    
+    uploaded_file = st.file_uploader(
+        "Choose network logs (CSV/TXT/PDF)",
+        type=["csv", "txt", "pdf"],
+        label_visibility="collapsed"
+    )
+    
+    if uploaded_file:
         try:
-            pdf_reader = PyPDF2.PdfReader(uploaded_file)
-            text = ""
-            for page in pdf_reader.pages:
-                text += page.extract_text()
-            df = pd.DataFrame({"text": [text]})
-            return df, "pdf"
+            process_file(uploaded_file)
+            st.session_state.file_uploaded = True
+            st.success("✅ File processed successfully!")
+            
+            # Show file summary
+            st.subheader("📋 Upload Summary")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Total Records", len(st.session_state.df))
+            with col2:
+                anomalies = sum(st.session_state.df['anomaly'] == -1)
+                st.metric("Anomalies Detected", f"{anomalies} ({anomalies/len(st.session_state.df)*100:.1f}%)")
+            with col3:
+                st.metric("Max Traffic", f"{st.session_state.df['traffic'].max():.2f} Mbps")
+
         except Exception as e:
-            st.error("Error reading PDF file.")
-            return None, None
-    else:
-        st.error("Unsupported file type.")
-        return None, None
-
-def run_local_anomaly_detection(df):
-    # Use IsolationForest for numeric data anomaly detection.
-    numeric_cols = df.select_dtypes(include=[np.number]).columns
-    if len(numeric_cols) < 2:
-        st.warning("Not enough numeric columns for anomaly detection. (Need at least 2 numeric columns)")
-        return df
-    X = df[numeric_cols].fillna(0)
-    model = IsolationForest(contamination=0.1, random_state=42)
-    model.fit(X)
-    df['anomaly'] = model.predict(X)
-    df['anomaly_flag'] = df['anomaly'].apply(lambda x: "🚨 Anomaly" if x == -1 else "✅ Normal")
-    return df
-
-def call_groq_api(df):
-    # ----- Dummy Groq API integration -----
-    # Replace this dummy call with an actual Groq API call as needed.
-    df = run_local_anomaly_detection(df)
-    return df
-
-def generate_plots(df):
-    # Generate 2D and 3D plots from the first numeric columns
-    numeric_cols = df.select_dtypes(include=[np.number]).columns
-    fig2d, fig3d = None, None
-    if len(numeric_cols) >= 2:
-        fig2d = px.scatter(df, x=numeric_cols[0], y=numeric_cols[1],
-                           color='anomaly_flag',
-                           title="📈 2D Anomaly Detection Plot")
-    if len(numeric_cols) >= 3:
-        fig3d = px.scatter_3d(df, x=numeric_cols[0], y=numeric_cols[1], z=numeric_cols[2],
-                              color='anomaly_flag',
-                              title="📊 3D Anomaly Detection Plot")
-    return fig2d, fig3d
-
-def generate_pdf_report(summary_text, fig2d, fig3d):
-    pdf = FPDF()
-    pdf.add_page()
-    pdf.set_font("Arial", 'B', 16)
-    pdf.cell(0, 10, "WiFi Anomaly Detection Report", ln=True)
-    pdf.ln(10)
-    pdf.set_font("Arial", size=12)
-    pdf.multi_cell(0, 10, summary_text)
-    pdf.ln(10)
+            st.error(f"Error processing file: {str(e)}")
+
+def visualization_section():
+    st.title("📊 Data Visualization")
+    st.markdown("---")
+    
+    # 2D Visualization
+    st.subheader("2D Traffic Analysis 🌐")
+    # Use 'timestamp' if available; if not, generate a dummy one
+    df = st.session_state.df.copy()
+    if 'timestamp' not in df.columns:
+        df['timestamp'] = pd.date_range(start="2021-01-01", periods=len(df), freq="T")
+    fig2d = px.scatter(
+        df,
+        x='timestamp',
+        y='traffic',
+        color='anomaly',
+        color_discrete_map={-1: 'orange', 1: 'blue'},
+        title="2D Traffic Analysis"
+    )
+    st.plotly_chart(fig2d, use_container_width=True)
     
-    # Save figures as temporary image files using Kaleido (Plotly's image export engine)
-    image_files = []
-    if fig2d is not None:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
-            fig2d.write_image(tmpfile.name)
-            image_files.append(tmpfile.name)
-    if fig3d is not None:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
-            fig3d.write_image(tmpfile.name)
-            image_files.append(tmpfile.name)
+    # 3D Visualization
+    st.subheader("3D Network Health 🌍")
+    fig3d = px.scatter_3d(
+        df,
+        x='latency',
+        y='packet_loss',
+        z='traffic',
+        color='anomaly',
+        color_discrete_map={-1: 'orange', 1: 'blue'},
+        title="3D Network Analysis"
+    )
+    st.plotly_chart(fig3d, use_container_width=True)
+
+def statistics_section():
+    st.title("📈 Statistical Analysis")
+    st.markdown("---")
     
-    # Add each image to the PDF
-    for image in image_files:
-        pdf.image(image, w=pdf.w - 40)
-        pdf.ln(10)
+    st.subheader("Data Summary 📝")
+    st.dataframe(st.session_state.df.describe(), use_container_width=True)
     
-    # Clean up temporary image files
-    for image in image_files:
-        os.remove(image)
+    st.subheader("Anomaly Distribution 📊")
+    anomaly_counts = st.session_state.df['anomaly'].value_counts()
+    fig = px.pie(
+        names=['Normal', 'Anomaly'],
+        values=[anomaly_counts.get(1, 0), anomaly_counts.get(-1, 0)],
+        hole=0.4,
+        color_discrete_sequence=['blue', 'orange'],
+        title="Anomaly Distribution"
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+def download_section():
+    st.title("📥 Download Report")
+    st.markdown("---")
     
-    pdf_data = pdf.output(dest="S").encode("latin1")
-    return pdf_data
-
-# -------------------------------
-# Initialize Session State Variables
-# -------------------------------
-if "step" not in st.session_state:
-    st.session_state.step = "upload"
-if "df" not in st.session_state:
-    st.session_state.df = None
-if "df_processed" not in st.session_state:
-    st.session_state.df_processed = None
-if "fig2d" not in st.session_state:
-    st.session_state.fig2d = None
-if "fig3d" not in st.session_state:
-    st.session_state.fig3d = None
-if "summary_text" not in st.session_state:
-    st.session_state.summary_text = ""
-
-# -------------------------------
-# Sidebar: Step Buttons
-# -------------------------------
-st.sidebar.title("🔧 Application Steps")
-if st.sidebar.button("📁 Upload File"):
-    st.session_state.step = "upload"
-if st.sidebar.button("📊 Data Visualization"):
-    st.session_state.step = "viz"
-if st.sidebar.button("📈 Statistic Analysis"):
-    st.session_state.step = "stats"
-if st.sidebar.button("⬇️ Download Report"):
-    st.session_state.step = "download"
-
-# -------------------------------
-# Main Workflow Based on Step
-# -------------------------------
-if st.session_state.step == "upload":
-    st.subheader("Step 1: Upload Your Data File")
-    st.markdown("Please upload a CSV, TXT, or PDF file with network data. The expected columns for CSV/TXT files are:")
-    st.code("['traffic', 'latency', 'packet_loss']", language="python")
-    uploaded_file = st.file_uploader("Choose a file", type=["csv", "txt", "pdf"])
-    if uploaded_file is not None:
-        df, file_type = load_data(uploaded_file)
-        if df is not None:
-            st.session_state.df = df
-            st.success("File uploaded and processed successfully!")
-            if file_type == "pdf":
-                st.subheader("Extracted Text from PDF:")
-                st.text_area("PDF Content", df["text"][0], height=300)
-            else:
-                st.subheader("Data Preview:")
-                st.dataframe(df.head())
-    else:
-        st.info("Awaiting file upload. 😊")
-
-elif st.session_state.step == "viz":
-    st.subheader("Step 2: Data Visualization")
-    if st.session_state.df is None:
-        st.error("Please upload a file first in the 'Upload File' step.")
-    else:
-        # Process the data if not already done
-        if st.session_state.df_processed is None:
-            # Here, you can choose between the local model or Groq API; we use the local model for demo.
-            st.session_state.df_processed = run_local_anomaly_detection(st.session_state.df)
-        fig2d, fig3d = generate_plots(st.session_state.df_processed)
-        st.session_state.fig2d = fig2d
-        st.session_state.fig3d = fig3d
-        if fig2d:
-            st.plotly_chart(fig2d, use_container_width=True)
-        if fig3d:
-            st.plotly_chart(fig3d, use_container_width=True)
-
-elif st.session_state.step == "stats":
-    st.subheader("Step 3: Statistic Analysis")
-    if st.session_state.df_processed is None:
-        st.error("Data has not been processed yet. Please complete the Data Visualization step first.")
-    else:
-        df_result = st.session_state.df_processed
-        anomaly_count = (df_result['anomaly'] == -1).sum()
-        total_count = df_result.shape[0]
-        st.session_state.summary_text = f"Total records: {total_count}\nDetected anomalies: {anomaly_count}"
-        st.markdown("**Anomaly Detection Summary:**")
-        st.text(st.session_state.summary_text)
-        st.markdown("**Detailed Data:**")
-        st.dataframe(df_result.head())
-        st.markdown("**Descriptive Statistics:**")
-        st.dataframe(df_result.describe())
-
-elif st.session_state.step == "download":
-    st.subheader("Step 4: Download PDF Report")
-    if st.session_state.df_processed is None or (st.session_state.fig2d is None and st.session_state.fig3d is None):
-        st.error("Please complete the previous steps (Upload, Visualization, Statistic Analysis) before downloading the report.")
-    else:
-        pdf_data = generate_pdf_report(st.session_state.summary_text, st.session_state.fig2d, st.session_state.fig3d)
-        st.download_button("⬇️ Download PDF Report", data=pdf_data,
-                           file_name="wifi_anomaly_report.pdf",
-                           mime="application/pdf")
+    if st.button("🖨️ Generate Full Report"):
+        with st.spinner("Generating PDF report..."):
+            generate_pdf_report()
+            st.success("Report generated successfully!")
+            
+    if 'pdf_report' in st.session_state:
+        st.markdown("---")
+        b64 = base64.b64encode(st.session_state.pdf_report).decode()
+        href = f'<a href="data:application/octet-stream;base64,{b64}" download="wifi_report.pdf">📥 Download Full Report</a>'
+        st.markdown(href, unsafe_allow_html=True)
+
+def process_file(uploaded_file):
+    try:
+        # Process CSV files
+        if uploaded_file.name.endswith('.csv'):
+            df = pd.read_csv(uploaded_file)
+        # Process TXT files
+        elif uploaded_file.name.endswith('.txt'):
+            lines = [line.decode().strip().split(',') for line in uploaded_file.readlines()]
+            df = pd.DataFrame(lines[1:], columns=lines[0])
+        # Process PDF files using pdfplumber
+        elif uploaded_file.name.endswith('.pdf'):
+            with pdfplumber.open(uploaded_file) as pdf:
+                text = '\n'.join([page.extract_text() for page in pdf.pages])
+            lines = [line.split(',') for line in text.split('\n') if line]
+            df = pd.DataFrame(lines[1:], columns=lines[0])
+        else:
+            raise ValueError("Unsupported file type.")
+        
+        # Ensure required numeric columns exist and convert them
+        numeric_cols = ['traffic', 'latency', 'packet_loss']
+        for col in numeric_cols:
+            if col not in df.columns:
+                raise ValueError(f"Column '{col}' not found in data.")
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        # Run anomaly detection using IsolationForest with 40% contamination
+        clf = IsolationForest(contamination=0.4, random_state=42)
+        df['anomaly'] = clf.fit_predict(df[numeric_cols])
+        
+        st.session_state.df = df
+
+    except Exception as e:
+        st.error(f"Error processing file: {str(e)}")
+        raise
+
+def generate_pdf_report():
+    try:
+        buffer = BytesIO()
+        doc = SimpleDocTemplate(buffer, pagesize=letter)
+        styles = getSampleStyleSheet()
+        elements = []
+        
+        # Custom Title Style
+        title_style = ParagraphStyle(
+            name='Title',
+            parent=styles['Heading1'],
+            fontSize=18,
+            textColor=colors.darkblue,
+            spaceAfter=14
+        )
+        
+        # Add Title
+        elements.append(Paragraph("WiFi Network Anomaly Detection", title_style))
+        elements.append(Spacer(1, 12))
+        
+        # Add Summary Section
+        elements.append(Paragraph("<b>Detection Summary:</b>", styles['Heading2']))
+        summary_text = f"""
+        • Total Data Points: {len(st.session_state.df)}<br/>
+        • Anomalies Detected: {sum(st.session_state.df['anomaly'] == -1)}<br/>
+        • Maximum Traffic: {st.session_state.df['traffic'].max():.2f} Mbps<br/>
+        • Average Latency: {st.session_state.df['latency'].mean():.2f} ms<br/>
+        • Peak Packet Loss: {st.session_state.df['packet_loss'].max():.2f}%<br/>
+        """
+        elements.append(Paragraph(summary_text, styles['BodyText']))
+        elements.append(PageBreak())
+        
+        # Generate and embed plots in memory using BytesIO
+        
+        # 2D Plot
+        df = st.session_state.df.copy()
+        if 'timestamp' not in df.columns:
+            df['timestamp'] = pd.date_range(start="2021-01-01", periods=len(df), freq="T")
+        fig2d = px.scatter(df, x='timestamp', y='traffic', 
+                           color='anomaly', title="2D Traffic Analysis",
+                           color_discrete_map={-1: 'orange', 1: 'blue'})
+        img_bytes_2d = fig2d.to_image(format="png", engine="kaleido")
+        img2d_io = BytesIO(img_bytes_2d)
+        
+        # 3D Plot
+        fig3d = px.scatter_3d(df, x='latency', y='packet_loss',
+                              z='traffic', color='anomaly', title="3D Network Analysis",
+                              color_discrete_map={-1: 'orange', 1: 'blue'})
+        img_bytes_3d = fig3d.to_image(format="png", engine="kaleido")
+        img3d_io = BytesIO(img_bytes_3d)
+        
+        # Add 2D Plot
+        elements.append(Paragraph("<b>2D Traffic Analysis</b>", styles['Heading2']))
+        elements.append(Image(img2d_io, width=6*inch, height=4*inch))
+        elements.append(Spacer(1, 12))
+        
+        # Add 3D Plot
+        elements.append(Paragraph("<b>3D Network Analysis</b>", styles['Heading2']))
+        elements.append(Image(img3d_io, width=6*inch, height=4*inch))
+        elements.append(PageBreak())
+        
+        # Add Statistics Section
+        elements.append(Paragraph("<b>Statistical Report</b>", styles['Heading1']))
+        stats = st.session_state.df.describe()
+        for col in ['traffic', 'latency', 'packet_loss']:
+            elements.append(Paragraph(f"<b>{col.capitalize()} Statistics:</b>", styles['Heading3']))
+            stats_text = f"""
+            • Mean: {stats[col]['mean']:.2f}<br/>
+            • Std Dev: {stats[col]['std']:.2f}<br/>
+            • Min: {stats[col]['min']:.2f}<br/>
+            • 25%: {stats[col]['25%']:.2f}<br/>
+            • 50%: {stats[col]['50%']:.2f}<br/>
+            • 75%: {stats[col]['75%']:.2f}<br/>
+            • Max: {stats[col]['max']:.2f}<br/>
+            """
+            elements.append(Paragraph(stats_text, styles['BodyText']))
+            elements.append(Spacer(1, 12))
+        
+        doc.build(elements)
+        st.session_state.pdf_report = buffer.getvalue()
+
+    except Exception as e:
+        st.error(f"Error generating report: {str(e)}")
+
+if __name__ == "__main__":
+    main()