Upload 6 files

app.py

@@ -0,0 +1,154 @@
+import gradio as gr
+import database
+import app_logic
+import visualization
+
+# 1. Initialize Database Schema and Sample Data on startup
+database.init_db()
+
+# --- Helper Functions for UI Logic ---
+
+def update_dropdown(category):
+    """
+    Triggered when Category changes. 
+    Updates the Product list and clears the review textbox.
+    """
+    names = app_logic.get_products_by_category(category)
+    return gr.Dropdown(choices=names, value=names[0] if names else None), ""
+
+def refresh_owner_dashboard():
+    """
+    Fetches the latest data for the Table and the latest Plotly Chart.
+    Used by the Refresh button and automatic updates.
+    """
+    table_data = app_logic.get_all_reviews()
+    chart_figure = visualization.generate_sentiment_pie_chart()
+    return table_data, chart_figure
+
+def validate_input(text):
+    """
+    Real-time 'Sense Check'. 
+    Disables the Submit button unless at least 3 words are typed.
+    """
+    word_count = len(text.strip().split())
+    if word_count >= 3:
+        # Enable button and make it primary (colored)
+        return gr.update(interactive=True, variant="primary")
+    else:
+        # Disable button and make it secondary (gray)
+        return gr.update(interactive=False, variant="secondary")
+
+# --- UI Layout using Gradio Blocks ---
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 👗 Women's Clothing Portal")
+    gr.Markdown("### AI-Powered Customer Feedback & Business Intelligence")
+
+    with gr.Tabs():
+        
+        # TAB 1: CUSTOMER INTERFACE
+        with gr.TabItem("Customer"):
+            gr.Markdown("#### Submit your Review")
+            with gr.Row():
+                with gr.Column():
+                    category_input = gr.Dropdown(
+                        choices=["Jeans", "Tops", "Kurti", "Leggings"], 
+                        value="Jeans", 
+                        label="Category"
+                    )
+                    product_input = gr.Dropdown(choices=[], label="Product Name")
+                    rating_input = gr.Slider(1, 5, step=1, value=5, label="Rating (1-5)")
+                    
+                    review_input = gr.Textbox(
+                        label="Review Text", 
+                        placeholder="Please write at least 3 words about the fit or quality...", 
+                        lines=4
+                    )
+                    
+                    # Submit button starts as DISABLED
+                    submit_btn = gr.Button("Submit Review", variant="secondary", interactive=False)
+                    status_output = gr.Textbox(label="Submission Status")
+
+        # TAB 2: OWNER DASHBOARD
+        with gr.TabItem("Owner Dashboard"):
+            gr.Markdown("#### Live Sentiment Analytics")
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Plotly Chart from visualization.py
+                    sentiment_plot = gr.Plot(label="Sentiment Distribution")
+                
+                with gr.Column(scale=1):
+                    refresh_btn = gr.Button("🔄 Refresh Database", variant="secondary")
+                    gr.Markdown("Updates the chart and table with the latest customer entries.")
+            
+            data_table = gr.Dataframe(label="Detailed Customer Feedback Log", interactive=False)
+
+        # TAB 3: AI BUSINESS INSIGHTS
+        with gr.TabItem("📈 AI Insights"):
+            gr.Markdown("#### Strategic Business Analysis")
+            gr.Markdown("Generate a deep-dive report based on all current customer feedback using Generative AI.")
+            
+            generate_report_btn = gr.Button("Generate AI Strategy Report", variant="primary")
+            report_output = gr.Markdown(value="*Report will appear here after clicking the button...*")
+
+    # --- UI Event Listeners ---
+
+    # 1. Real-time Word Count Validation
+    review_input.change(
+        fn=validate_input, 
+        inputs=review_input, 
+        outputs=submit_btn
+    )
+
+    # 2. Category -> Product Dropdown Sync
+    category_input.change(
+        fn=update_dropdown, 
+        inputs=category_input, 
+        outputs=[product_input, review_input]
+    )
+
+    # 3. Clear review text when product changes
+    product_input.change(lambda: "", outputs=review_input)
+
+    # 4. Main Submission Logic (Saves to DB, Updates Chart, Resets UI)
+    submit_btn.click(
+        fn=app_logic.save_review, 
+        inputs=[product_input, rating_input, review_input], 
+        outputs=status_output
+    ).then(
+        # Auto-update the dashboard
+        fn=refresh_owner_dashboard, 
+        outputs=[data_table, sentiment_plot]
+    ).then(
+        # Clear the text box
+        fn=lambda: "", outputs=review_input
+    ).then(
+        # Re-disable the button
+        fn=lambda: gr.update(interactive=False, variant="secondary"), 
+        outputs=submit_btn
+    )
+
+    # 5. Manual Dashboard Refresh
+    refresh_btn.click(
+        fn=refresh_owner_dashboard, 
+        outputs=[data_table, sentiment_plot]
+    )
+
+    # 6. AI Report Generation
+    generate_report_btn.click(
+        fn=app_logic.generate_business_report,
+        outputs=report_output
+    )
+
+    # 7. Initial Load (Ensures data is visible when the page first opens)
+    demo.load(refresh_owner_dashboard, outputs=[data_table, sentiment_plot])
+    demo.load(
+        fn=update_dropdown, 
+        inputs=category_input, 
+        outputs=[product_input, review_input]
+    )
+
+# --- Launch the Application ---
+if __name__ == "__main__":
+    # Use share=True if you want to create a public link
+    demo.launch()

app_logic.py

@@ -0,0 +1,91 @@
+import sqlite3
+import pandas as pd
+from datetime import datetime
+from database import query_db, DB_NAME
+# UPDATED: Changed from sentiment2 to sentiment
+from sentiment import analyze_sentiment, client 
+
+def get_products_by_category(category):
+    results = query_db("SELECT name FROM products WHERE category = ?", (category,), fetch=True)
+    return [row[0] for row in results]
+
+def save_review(product_name, rating, review_text):
+    """
+    Validates the input, runs sentiment analysis, and saves to SQLite.
+    """
+    # 1. Validation: No empty strings
+    if not review_text or not review_text.strip():
+        return "⚠️ Error: Review text cannot be empty!"
+    
+    # 2. Validation: Minimum 3 words (Matches UI logic)
+    word_count = len(review_text.strip().split())
+    if word_count < 3:
+        return "⚠️ Error: Please write at least 3 words."
+
+    # 3. Database lookup for product ID
+    result = query_db("SELECT id FROM products WHERE name = ?", (product_name,), fetch=True)
+    
+    if result:
+        product_id = result[0][0]
+        
+        # 4. Sentiment Analysis (using logic from sentiment.py)
+        sentiment = analyze_sentiment(review_text, rating=int(rating))
+        
+        # 5. Save to Database
+        date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        query_db("""INSERT INTO reviews (product_id, rating, review_text, sentiment, date) 
+                    VALUES (?, ?, ?, ?, ?)""",
+                 (product_id, int(rating), review_text, sentiment, date_str))
+        
+        return f"✅ Saved! Sentiment detected: {sentiment}"
+    
+    return "❌ Error: Product not found."
+
+def generate_business_report():
+    """Fetches all reviews and sends them to Groq for a summary report."""
+    conn = sqlite3.connect(DB_NAME)
+    query = """
+    SELECT p.name, r.rating, r.sentiment, r.review_text 
+    FROM products p JOIN reviews r ON p.id = r.product_id
+    """
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+
+    if df.empty:
+        return "No data found. Collect some reviews first!"
+
+    # Create a string of all reviews for the AI to read
+    review_summary = ""
+    for _, row in df.iterrows():
+        review_summary += f"- {row['name']} ({row['rating']} stars, {row['sentiment']}): {row['review_text']}\n"
+
+    prompt = f"Analyze these clothing reviews and provide a summary of satisfaction, top issues, and an action plan:\n\n{review_summary}"
+
+    try:
+        # Uses the client imported from sentiment.py
+        completion = client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a concise business consultant."},
+                {"role": "user", "content": prompt}
+            ],
+            model="llama-3.1-8b-instant",
+            temperature=0.5,
+            max_tokens=500
+        )
+        return completion.choices[0].message.content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def get_all_reviews():
+    """Returns a DataFrame for the Owner's table."""
+    conn = sqlite3.connect(DB_NAME)
+    try:
+        query = """
+        SELECT p.category, p.name as product_name, r.rating, r.sentiment, r.review_text, r.date 
+        FROM products p 
+        JOIN reviews r ON p.id = r.product_id
+        ORDER BY r.date DESC
+        """
+        return pd.read_sql_query(query, conn)
+    finally:
+        conn.close()

database.py

@@ -0,0 +1,41 @@
+import sqlite3
+
+DB_NAME = "clothing_reviews.db"
+
+def init_db():
+    conn = sqlite3.connect(DB_NAME)
+    cursor = conn.cursor()
+    cursor.execute('''CREATE TABLE IF NOT EXISTS products 
+                      (id INTEGER PRIMARY KEY, category TEXT, name TEXT)''')
+    cursor.execute('''CREATE TABLE IF NOT EXISTS reviews 
+                  (id INTEGER PRIMARY KEY, product_id INTEGER, 
+                   rating INTEGER, review_text TEXT, 
+                   sentiment TEXT, date TEXT)''')
+    
+    cursor.execute("SELECT COUNT(*) FROM products")
+    if cursor.fetchone()[0] == 0:
+        sample_products = [
+            ('Kurti', 'Embroidered Cotton Chikankari Kurti'),
+            ('Jeans', 'High-Waisted Distressed Skinny Jeans'),
+            ('Tops', 'Floral Print Peplum Blouse'),
+            ('Leggings', 'High-Performance Seamless Yoga Leggings'),
+            ('Kurti', 'Anarkali Style Floor-Length Kurti'),
+            ('Tops', 'Oversized Linen Button-Down Shirt'),
+            ('Jeans', 'Classic Straight-Leg Denim'),
+            ('Leggings', 'Fleece-Lined Winter Thermal Leggings'),
+            ('Kurti', 'Straight-Cut Rayon Daily Wear Kurti'),
+            ('Tops', 'Silk Camisole with Lace Trim')
+        ]
+        cursor.executemany("INSERT INTO products (category, name) VALUES (?, ?)", sample_products)
+    
+    conn.commit()
+    conn.close()
+
+def query_db(query, params=(), fetch=False):
+    conn = sqlite3.connect(DB_NAME)
+    cursor = conn.cursor()
+    cursor.execute(query, params)
+    result = cursor.fetchall() if fetch else None
+    conn.commit()
+    conn.close()
+    return result

requirements.txt.txt

@@ -0,0 +1,5 @@
+gradio
+groq
+python-dotenv
+pandas
+plotly

sentiment.py

@@ -0,0 +1,70 @@
+import os
+import re
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+
+def is_meaningful(text):
+    """Checks if the text contains actual words or just gibberish."""
+    text_stripped = text.strip()
+    
+    # 1. Basic length check (already enforced by UI, but good for safety)
+    if len(text_stripped) < 3:
+        return False
+
+    # 2. Check for vowel ratio (catches 'bdfghj')
+    vowels = len(re.findall(r'[aeiouAEIOU]', text_stripped))
+    total_chars = len(re.findall(r'[a-zA-Z]', text_stripped))
+    if total_chars > 0 and (vowels / total_chars) < 0.1:
+        return False 
+
+    # 3. Check for repetitive characters (catches 'aaaaaa')
+    if re.search(r'(.)\1{4,}', text_stripped):
+        return False
+        
+    return True
+
+def analyze_sentiment(review_text, rating=3):
+    """
+    Core sentiment logic. Gibberish is filtered locally; 
+    meaningful text is analyzed by Llama 3.1.
+    """
+    text_clean = str(review_text).strip()
+
+    # --- STEP 1: SENSE CHECK (GIBBERISH FILTER) ---
+    if not is_meaningful(text_clean):
+        return "Neutral"
+
+    # --- STEP 2: AI LOGIC ---
+    # Enhanced prompt to ensure 'bad product' is caught as Negative
+    system_msg = (
+        "You are a strict sentiment classifier. Output ONLY one word: Positive, Negative, or Neutral. "
+        "Priority Rule: If the text contains negative words (bad, poor, hate, worst), "
+        "the output MUST be Negative, regardless of the star rating."
+    )
+    
+    user_prompt = f"Review Text: '{text_clean}'\nStar Rating: {rating}/5\nSentiment:"
+
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": system_msg},
+                {"role": "user", "content": user_prompt}
+            ],
+            model="llama-3.1-8b-instant",
+            temperature=0, # Zero temperature ensures the most predictable result
+            max_tokens=3 
+        )
+        
+        # Clean the output from the AI
+        result = chat_completion.choices[0].message.content.strip().replace(".", "")
+        
+        if result in ["Positive", "Negative", "Neutral"]:
+            return result
+        return "Neutral"
+        
+    except Exception as e:
+        print(f"Error calling Groq API: {e}")
+        return "Neutral"

visualization.py

@@ -0,0 +1,40 @@
+import sqlite3
+import pandas as pd
+import plotly.express as px
+from database import DB_NAME
+
+def generate_sentiment_pie_chart():
+    """Fetches data and returns a Plotly Pie Chart figure."""
+    conn = sqlite3.connect(DB_NAME)
+    # Fetch only the sentiment column
+    df = pd.read_sql_query("SELECT sentiment FROM reviews", conn)
+    conn.close()
+    
+    if df.empty:
+        # Return a simple figure with a message if no reviews exist
+        fig = px.pie(title="No reviews collected yet.")
+        return fig
+    
+    # Process data for the chart
+    counts = df['sentiment'].value_counts().reset_index()
+    counts.columns = ['Sentiment', 'Total']
+    
+    # Create the chart
+    fig = px.pie(
+        counts, 
+        values='Total', 
+        names='Sentiment', 
+        title='Customer Sentiment Distribution',
+        # Professional color mapping
+        color='Sentiment',
+        color_discrete_map={
+            'Positive': '#2ecc71', # Emerald Green
+            'Negative': '#e74c3c', # Alizarin Red
+            'Neutral': '#f1c40f'   # Sunflower Yellow
+        }
+    )
+    
+    # Update layout for a cleaner look
+    fig.update_layout(showlegend=True, margin=dict(t=50, b=20, l=20, r=20))
+    
+    return fig