something

app.py

@@ -3,22 +3,424 @@ import plotly.express as px
 import plotly.graph_objects as go
 import pandas as pd
 import numpy as np
-from datetime import datetime
-
-# --- App Configuration ---
-st.set_page_config(
-    page_title="Prospira | Data-Driven Business Insights",
-    page_icon="📈",
-    layout="wide"
-)
-
-# --- Sidebar Navigation ---
-st.sidebar.image("https://via.placeholder.com/150", use_column_width=True)  # Placeholder for Prospira logo
-st.sidebar.title("Prospira Navigation")
-page = st.sidebar.radio("Go to", ["🏠 Home", "📊 Business Dashboard", "🔍 Data Analytics", "💡 Brainstorm Hub", "🤖 AI Assistant"])
-
-# --- Homepage ---
-if page == "🏠 Home":
+from datetime import datetime, timedelta
+from typing import Dict, List, Any
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import streamlit as st
+
+# --- Data Processing Class ---
+class DataProcessor:
+    def __init__(self):
+        self.data = None
+        self.numeric_columns = []
+        self.categorical_columns = []
+        self.date_columns = []
+    
+    def load_data(self, file) -> bool:
+        try:
+            self.data = pd.read_csv(file)
+            self._classify_columns()
+            return True
+        except Exception as e:
+            st.error(f"Error loading data: {str(e)}")
+            return False
+    
+    def _classify_columns(self):
+        for col in self.data.columns:
+            if pd.api.types.is_numeric_dtype(self.data[col]):
+                self.numeric_columns.append(col)
+            elif pd.api.types.is_datetime64_any_dtype(self.data[col]):
+                self.date_columns.append(col)
+            else:
+                try:
+                    pd.to_datetime(self.data[col])
+                    self.date_columns.append(col)
+                except:
+                    self.categorical_columns.append(col)
+
+    def get_basic_stats(self) -> Dict[str, Any]:
+        if self.data is None:
+            return {}
+        
+        stats = {
+            'summary': self.data[self.numeric_columns].describe(),
+            'missing_values': self.data.isnull().sum(),
+            'row_count': len(self.data),
+            'column_count': len(self.data.columns)
+        }
+        return stats
+
+    def create_visualization(self, chart_type: str, x_col: str, y_col: str, color_col: str = None) -> go.Figure:
+        if chart_type == "Line Plot":
+            fig = px.line(self.data, x=x_col, y=y_col, color=color_col)
+        elif chart_type == "Bar Plot":
+            fig = px.bar(self.data, x=x_col, y=y_col, color=color_col)
+        elif chart_type == "Scatter Plot":
+            fig = px.scatter(self.data, x=x_col, y=y_col, color=color_col)
+        elif chart_type == "Box Plot":
+            fig = px.box(self.data, x=x_col, y=y_col, color=color_col)
+        else:
+            fig = px.histogram(self.data, x=x_col, color=color_col)
+        
+        return fig
+
+class BrainstormManager:
+    def __init__(self):
+        if 'products' not in st.session_state:
+            st.session_state.products = {}
+        
+    def generate_product_form(self) -> Dict:
+        with st.form("product_form"):
+            basic_info = {
+                "name": st.text_input("Product Name"),
+                "category": st.selectbox("Category", ["Digital", "Physical", "Service"]),
+                "description": st.text_area("Description"),
+                "target_audience": st.multiselect("Target Audience", 
+                    ["Students", "Professionals", "Businesses", "Seniors", "Youth"]),
+                "price_range": st.slider("Price Range ($)", 0, 1000, (50, 200)),
+                "launch_date": st.date_input("Expected Launch Date")
+            }
+            
+            st.subheader("Market Analysis")
+            market_analysis = {
+                "competitors": st.text_area("Main Competitors (one per line)"),
+                "unique_features": st.text_area("Unique Selling Points"),
+                "market_size": st.selectbox("Market Size", 
+                    ["Small", "Medium", "Large", "Enterprise"]),
+                "growth_potential": st.slider("Growth Potential", 1, 10)
+            }
+            
+            submitted = st.form_submit_button("Save Product")
+            return basic_info, market_analysis, submitted
+
+    def analyze_product(self, product_data: Dict) -> Dict:
+        insights = {
+            "market_opportunity": self._calculate_opportunity_score(product_data),
+            "suggested_price": self._suggest_price(product_data),
+            "risk_factors": self._identify_risks(product_data),
+            "next_steps": self._generate_next_steps(product_data)
+        }
+        return insights
+
+    def _calculate_opportunity_score(self, data: Dict) -> int:
+        score = 0
+        if data.get("market_size") == "Large":
+            score += 3
+        if len(data.get("target_audience", [])) >= 2:
+            score += 2
+        if data.get("growth_potential", 0) > 7:
+            score += 2
+        return min(score, 10)
+
+    def _suggest_price(self, data: Dict) -> float:
+        base_price = sum(data.get("price_range", (0, 0))) / 2
+        if data.get("market_size") == "Enterprise":
+            base_price *= 1.5
+        return round(base_price, 2)
+
+    def _identify_risks(self, data: Dict) -> List[str]:
+        risks = []
+        if data.get("competitors"):
+            risks.append("Competitive market - differentiation crucial")
+        if len(data.get("target_audience", [])) < 2:
+            risks.append("Narrow target audience - consider expansion")
+        return risks
+
+    def _generate_next_steps(self, data: Dict) -> List[str]:
+        steps = [
+            "Create detailed product specification",
+            "Develop MVP timeline",
+            "Plan marketing strategy"
+        ]
+        if data.get("market_size") == "Enterprise":
+            steps.append("Prepare enterprise sales strategy")
+        return steps
+
+# --- Sample Data Generation ---
+def generate_sample_data():
+    dates = pd.date_range(start='2024-01-01', end='2024-01-31', freq='D')
+    return pd.DataFrame({
+        'Date': dates,
+        'Revenue': np.random.normal(1000, 100, len(dates)),
+        'Users': np.random.randint(100, 200, len(dates)),
+        'Engagement': np.random.uniform(0.5, 0.9, len(dates)),
+        'Category': np.random.choice(['A', 'B', 'C'], len(dates))
+    })
+
+# --- Page Rendering Functions ---
+def render_dashboard():
+    st.header("📊 Comprehensive Business Performance Dashboard")
+    
+    # Generate sample data with more complex structure
+    data = generate_sample_data()
+    data['Profit_Margin'] = data['Revenue'] * np.random.uniform(0.1, 0.3, len(data))
+    
+    # Top-level KPI Section
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("Total Revenue", 
+                  f"${data['Revenue'].sum():,.2f}", 
+                  delta=f"{data['Revenue'].pct_change().mean()*100:.2f}%")
+    with col2:
+        st.metric("Total Users", 
+                  f"{data['Users'].sum():,}", 
+                  delta=f"{data['Users'].pct_change().mean()*100:.2f}%")
+    with col3:
+        st.metric("Avg Engagement", 
+                  f"{data['Engagement'].mean():.2%}", 
+                  delta=f"{data['Engagement'].pct_change().mean()*100:.2f}%")
+    with col4:
+        st.metric("Profit Margin", 
+                  f"{data['Profit_Margin'].mean():.2%}", 
+                  delta=f"{data['Profit_Margin'].pct_change().mean()*100:.2f}%")
+    
+    # Visualization Grid
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Revenue & Profit Trends")
+        fig_revenue = go.Figure()
+        fig_revenue.add_trace(go.Scatter(
+            x=data['Date'], 
+            y=data['Revenue'], 
+            mode='lines', 
+            name='Revenue',
+            line=dict(color='blue')
+        ))
+        fig_revenue.add_trace(go.Scatter(
+            x=data['Date'], 
+            y=data['Profit_Margin'], 
+            mode='lines', 
+            name='Profit Margin',
+            line=dict(color='green')
+        ))
+        fig_revenue.update_layout(height=350)
+        st.plotly_chart(fig_revenue, use_container_width=True)
+    
+    with col2:
+        st.subheader("User Engagement Analysis")
+        fig_engagement = px.scatter(
+            data, 
+            x='Users', 
+            y='Engagement', 
+            color='Category', 
+            size='Revenue',
+            hover_data=['Date'],
+            title='User Engagement Dynamics'
+        )
+        fig_engagement.update_layout(height=350)
+        st.plotly_chart(fig_engagement, use_container_width=True)
+    
+    # Category Performance
+    st.subheader("Category Performance Breakdown")
+    category_performance = data.groupby('Category').agg({
+        'Revenue': 'sum',
+        'Users': 'sum',
+        'Engagement': 'mean'
+    }).reset_index()
+    
+    fig_category = px.bar(
+        category_performance, 
+        x='Category', 
+        y='Revenue', 
+        color='Engagement',
+        title='Revenue by Category with Engagement Overlay'
+    )
+    st.plotly_chart(fig_category, use_container_width=True)
+    
+    # Bottom Summary
+    st.subheader("Quick Insights")
+    insights_col1, insights_col2 = st.columns(2)
+    
+    with insights_col1:
+        st.metric("Top Performing Category", 
+                  category_performance.loc[category_performance['Revenue'].idxmax(), 'Category'])
+    
+    with insights_col2:
+        st.metric("Highest Engagement Category", 
+                  category_performance.loc[category_performance['Engagement'].idxmax(), 'Category'])
+
+def render_analytics():
+    st.header("🔍 Data Analytics")
+    
+    processor = DataProcessor()
+    uploaded_file = st.file_uploader("Upload your CSV data", type=['csv'])
+    
+    if uploaded_file is not None:
+        if processor.load_data(uploaded_file):
+            st.success("Data loaded successfully!")
+            
+            tabs = st.tabs(["Data Preview", "Statistics", "Visualization", "Metrics"])
+            
+            with tabs[0]:
+                st.subheader("Data Preview")
+                st.dataframe(processor.data.head())
+                st.info(f"Total rows: {len(processor.data)}, Total columns: {len(processor.data.columns)}")
+            
+            with tabs[1]:
+                st.subheader("Basic Statistics")
+                stats = processor.get_basic_stats()
+                st.write(stats['summary'])
+                
+                st.subheader("Missing Values")
+                st.write(stats['missing_values'])
+            
+            with tabs[2]:
+                st.subheader("Create Visualization")
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    chart_type = st.selectbox(
+                        "Select Chart Type",
+                        ["Line Plot", "Bar Plot", "Scatter Plot", "Box Plot", "Histogram"]
+                    )
+                
+                with col2:
+                    x_col = st.selectbox("Select X-axis", processor.data.columns)
+                
+                with col3:
+                    y_col = st.selectbox("Select Y-axis", processor.numeric_columns) if chart_type != "Histogram" else None
+                
+                color_col = st.selectbox("Select Color Variable (optional)", 
+                                       ['None'] + processor.categorical_columns)
+                color_col = None if color_col == 'None' else color_col
+                
+                fig = processor.create_visualization(
+                    chart_type,
+                    x_col,
+                    y_col if y_col else x_col,
+                    color_col
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with tabs[3]:
+                st.subheader("Column Metrics")
+                selected_col = st.selectbox("Select column", processor.numeric_columns)
+                
+                metrics = {
+                    'Mean': processor.data[selected_col].mean(),
+                    'Median': processor.data[selected_col].median(),
+                    'Std Dev': processor.data[selected_col].std(),
+                    'Min': processor.data[selected_col].min(),
+                    'Max': processor.data[selected_col].max()
+                }
+                
+                cols = st.columns(len(metrics))
+                for col, (metric, value) in zip(cols, metrics.items()):
+                    col.metric(metric, f"{value:.2f}")
+
+def render_brainstorm_page():
+    st.title("Product Brainstorm Hub")
+    manager = BrainstormManager()
+    
+    action = st.sidebar.radio("Action", ["View Products", "Create New Product"])
+    
+    if action == "Create New Product":
+        basic_info, market_analysis, submitted = manager.generate_product_form()
+        
+        if submitted:
+            product_data = {**basic_info, **market_analysis}
+            insights = manager.analyze_product(product_data)
+            
+            product_id = f"prod_{len(st.session_state.products)}"
+            st.session_state.products[product_id] = {
+                "data": product_data,
+                "insights": insights,
+                "created_at": str(datetime.now())
+            }
+            
+            st.success("Product added! View insights in the Products tab.")
+    
+    else:
+        if st.session_state.products:
+            for prod_id, product in st.session_state.products.items():
+                with st.expander(f"🎯 {product['data']['name']}"):
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.subheader("Product Details")
+                        st.write(f"Category: {product['data']['category']}")
+                        st.write(f"Target: {', '.join(product['data']['target_audience'])}")
+                        st.write(f"Description: {product['data']['description']}")
+                    
+                    with col2:
+                        st.subheader("Insights")
+                        st.metric("Opportunity Score", f"{product['insights']['market_opportunity']}/10")
+                        st.metric("Suggested Price", f"${product['insights']['suggested_price']}")
+                        
+                        st.write("**Risk Factors:**")
+                        for risk in product['insights']['risk_factors']:
+                            st.write(f"- {risk}")
+                        
+                        st.write("**Next Steps:**")
+                        for step in product['insights']['next_steps']:
+                            st.write(f"- {step}")
+        else:
+            st.info("No products yet. Create one to get started!")
+
+
+class LLaMAAssistant:
+    def __init__(self, model_name="meta-llama/Llama-2-7b-chat-hf"):
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_name, 
+                torch_dtype=torch.float16, 
+                device_map="auto"
+            )
+        except Exception as e:
+            st.error(f"Model loading error: {e}")
+            self.model = None
+            self.tokenizer = None
+
+    def generate_response(self, prompt: str, context: list = None) -> str:
+        if not self.model or not self.tokenizer:
+            return "LLM not initialized. Please check model configuration."
+        
+        # Prepare conversation context
+        if context is None:
+            context = []
+        
+        # Create full prompt with conversation history
+        full_prompt = "".join([f"{msg['role']}: {msg['content']}\n" for msg in context])
+        full_prompt += f"user: {prompt}\nassistant: "
+        
+        # Tokenize input
+        input_ids = self.tokenizer(full_prompt, return_tensors="pt").input_ids.to(self.model.device)
+        
+        # Generate response
+        try:
+            output = self.model.generate(
+                input_ids, 
+                max_length=500,
+                num_return_sequences=1,
+                no_repeat_ngram_size=2,
+                temperature=0.7,
+                top_p=0.9
+            )
+            
+            # Decode response
+            response = self.tokenizer.decode(output[0], skip_special_tokens=True)
+            
+            # Extract only the new part of the response
+            response = response[len(full_prompt):].strip()
+            
+            return response
+        except Exception as e:
+            return f"Response generation error: {e}"
+
+def render_chat():
+    st.header("💬AI Business Mentor")
+     st.title("🤖 Prospira AI Business Mentor")
+
+    st.write("""
+    <iframe
+        src="https://demoorganisation34-chatbot-for-prospira.hf.space"
+    ></iframe>
+    """, unsafe_allow_html=True)
+
+def render_home():
     st.title("🚀 Welcome to Prospira")
     st.subheader("📊 Data-Driven Solutions for Businesses and Creators")
 
@@ -30,103 +432,27 @@ if page == "🏠 Home":
     - **🔎 Competitive Analysis:** Benchmark your business against competitors.
     - **💡 Smart Product Ideas:** AI-generated recommendations for future products and content.
     - **🧠 AI Business Mentor:** Personalized AI guidance for strategy and growth.
-
     Explore how **Prospira** can help optimize your decision-making and drive success! 💡🚀
     """)
 
-    st.image("https://via.placeholder.com/800x400", use_column_width=True)  # Placeholder for banner image
-
-# --- Business Dashboard ---
-elif page == "📊 Business Dashboard":
-    st.title("📊 Prospira Business Dashboard")
-    st.subheader("Real-time Performance Insights")
-
-    # Generate Sample Business Data
-    dates = pd.date_range(start='2024-01-01', end='2024-01-31')
-    data = pd.DataFrame({
-        'Date': dates,
-        'Revenue': np.random.randint(800, 5000, len(dates)),
-        'Users': np.random.randint(100, 500, len(dates)),
-        'Engagement': np.random.uniform(0.3, 0.9, len(dates)),
-        'Profit': np.random.uniform(200, 1500, len(dates)),
-        'Category': np.random.choice(['Social Media', 'E-commerce', 'SaaS', 'Services'], len(dates))
-    })
-
-    # Top-Level KPIs
-    col1, col2, col3, col4 = st.columns(4)
-    col1.metric("Total Revenue", f"${data['Revenue'].sum():,.0f}")
-    col2.metric("Total Users", f"{data['Users'].sum():,}")
-    col3.metric("Avg Engagement", f"{data['Engagement'].mean():.2%}")
-    col4.metric("Profit", f"${data['Profit'].sum():,.0f}")
-
-    # Revenue & Profit Trends
-    st.subheader("📈 Revenue & Profit Trends")
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=data['Date'], y=data['Revenue'], mode='lines', name='Revenue', line=dict(color='blue')))
-    fig.add_trace(go.Scatter(x=data['Date'], y=data['Profit'], mode='lines', name='Profit', line=dict(color='green')))
-    st.plotly_chart(fig, use_container_width=True)
-
-    # Category Performance Breakdown
-    st.subheader("📊 Category Performance")
-    category_summary = data.groupby('Category')[['Revenue', 'Users', 'Engagement']].mean().reset_index()
-    fig_bar = px.bar(category_summary, x='Category', y='Revenue', color='Engagement', title="Revenue by Category")
-    st.plotly_chart(fig_bar, use_container_width=True)
-
-# --- Data Analytics Page ---
-elif page == "🔍 Data Analytics":
-    st.title("🔍 Upload and Analyze Your Data")
-
-    uploaded_file = st.file_uploader("Upload your CSV file", type=['csv'])
-    if uploaded_file:
-        df = pd.read_csv(uploaded_file)
-        st.write("### Preview of Your Data:")
-        st.dataframe(df.head())
-
-        st.write("### 📊 Basic Statistics")
-        st.write(df.describe())
-
-        st.write("### 📈 Data Visualization")
-        col1, col2 = st.columns(2)
-        x_col = col1.selectbox("X-Axis", df.columns)
-        y_col = col2.selectbox("Y-Axis", df.columns)
-
-        fig = px.scatter(df, x=x_col, y=y_col, title=f"Scatter Plot of {x_col} vs {y_col}")
-        st.plotly_chart(fig, use_container_width=True)
-
-# --- Brainstorming Hub ---
-elif page == "💡 Brainstorm Hub":
-    st.title("💡 AI-Powered Product Brainstorming")
-
-    product_name = st.text_input("Product Name")
-    category = st.selectbox("Category", ["Digital", "Physical", "Service"])
-    audience = st.multiselect("Target Audience", ["Students", "Professionals", "Businesses"])
-    description = st.text_area("Product Description")
-    price_range = st.slider("Price Range ($)", 0, 1000, (50, 200))
-
-    if st.button("Generate Insights"):
-        st.success("AI-generated insights will appear here.")
-        st.write(f"💡 **Suggested Price**: ${np.mean(price_range):.2f}")
-        st.write(f"🚀 **Market Opportunity**: High")
-
-# --- AI Assistant Page ---
-elif page == "🤖 AI Assistant":
-    st.title("🤖 Prospira AI Business Mentor")
-
-    def render_chat():
-        st.header("💬 Business AI Assistant")
+def main():
+    st.set_page_config(
+        page_title="Prospira",
         
-        # Embed the Hugging Face Space iframe
-        st.write("""
-        <iframe
-            src="https://demoorganisation34-chatbot-for-prospira.hf.space"
-            frameborder="0"
-            width="850"
-            height="450"
-        ></iframe>
-        """, unsafe_allow_html=True)
-
-    user_input = st.text_area("Ask Prospira AI for Business Advice:")
-    if st.button("Get AI Insights"):
-        response = assistant.generate_response(user_input)
-        st.write("**🧠 AI Response:**")
-        st.info(response)
+        page = st.radio(
+            "Navigation",
+            ["Home", "Dashboard", "Analytics", "Brainstorm", "Chat"]
+        )
+    if page == "Home":
+        render_home()
+    if page == "Dashboard":
+        render_dashboard()
+    elif page == "Analytics":
+        render_analytics()
+    elif page == "Brainstorm":
+        render_brainstorm_page()
+    elif page == "Chat":
+        render_chat()
+
+if __name__ == "__main__":
+    main()