Upload 10 files

market_overview.py

@@ -1,5 +1,5 @@
 import streamlit as st
-import matplotlib.pyplot as plt
+import plotly.graph_objects as go
 import pandas as pd # Added import statement for pandas
 from utils.data_loader import load_nifty50_symbols, fetch_stock_data, get_stock_info
 
@@ -82,7 +82,7 @@ with cols[2]:
     st.dataframe(pd.DataFrame(active_data))
 
 # Sector Performance Heat Map
-st.subheader(f"{selected_sector} Performance Overview")
+st.subheader(f"{selected_sector} Performance Heat Map")
 heat_map_data = []
 for symbol in sectors[selected_sector]:
     data = fetch_stock_data(symbol, period='1d')
@@ -92,16 +92,32 @@ for symbol in sectors[selected_sector]:
         heat_map_data.append({
             'Company': info['name'],
             'Symbol': symbol,
-            'Change%': change
+            'Change%': change,
+            'Market Cap': info['market_cap'],
+            'Volume': info['volume']
         })
 
 if heat_map_data:
-    df = pd.DataFrame(heat_map_data)
-    fig, ax = plt.subplots(figsize=(10, 5))
-    ax.barh(df['Company'], df['Change%'], color=['green' if x > 0 else 'red' for x in df['Change%']])
-    ax.set_xlabel("Change %")
-    ax.set_title(f"{selected_sector} Performance Overview")
-    st.pyplot(fig)
+    fig = go.Figure(data=[go.Treemap(
+        labels=[f"{d['Company']}<br>{d['Symbol']}" for d in heat_map_data],
+        parents=[''] * len(heat_map_data),
+        values=[d['Market Cap'] for d in heat_map_data],
+        textinfo="label+value+percent",
+        marker=dict(
+            colors=[d['Change%'] for d in heat_map_data],
+            colorscale='RdYlGn',
+            showscale=True
+        ),
+        hovertemplate="""
+        Company: %{label}<br>
+        Change: %{color:.2f}%<br>
+        Market Cap: ₹%{value:,.0f}<br>
+        <extra></extra>
+        """
+    )])
+
+    fig.update_layout(title=f"{selected_sector} Companies Heat Map")
+    st.plotly_chart(fig, use_container_width=True)
 
 # Detailed Sector Analysis
 st.subheader(f"{selected_sector} Companies")
@@ -120,4 +136,4 @@ for symbol in sectors[selected_sector]:
         })
 
 if detailed_data:
-    st.dataframe(pd.DataFrame(detailed_data))
+    st.dataframe(pd.DataFrame(detailed_data))

pages/market_overview.py

@@ -0,0 +1,139 @@
+import streamlit as st
+import plotly.graph_objects as go
+import pandas as pd # Added import statement for pandas
+from utils.data_loader import load_nifty50_symbols, fetch_stock_data, get_stock_info
+
+st.title("Market Overview")
+
+# Create sector categories
+sectors = {
+    "IT": ["TCS.NS", "INFY.NS", "HCLTECH.NS", "TECHM.NS", "WIPRO.NS"],
+    "Banking & Finance": ["HDFCBANK.NS", "ICICIBANK.NS", "SBIN.NS", "AXISBANK.NS", "KOTAKBANK.NS",
+                         "BAJFINANCE.NS", "BAJAJFINSV.NS", "HDFC.NS", "INDUSINDBK.NS"],
+    "Energy & Oil": ["RELIANCE.NS", "ONGC.NS", "POWERGRID.NS", "NTPC.NS", "BPCL.NS"],
+    "Automobile": ["TATAMOTORS.NS", "M&M.NS", "MARUTI.NS", "HEROMOTOCO.NS", "EICHERMOT.NS"],
+    "Consumer Goods": ["HINDUNILVR.NS", "ITC.NS", "NESTLEIND.NS", "BRITANNIA.NS", "TITAN.NS"],
+    "Metals & Mining": ["TATASTEEL.NS", "HINDALCO.NS", "JSWSTEEL.NS", "COALINDIA.NS"],
+    "Pharmaceuticals": ["SUNPHARMA.NS", "DRREDDY.NS", "CIPLA.NS", "DIVISLAB.NS"],
+    "Infrastructure": ["LT.NS", "ADANIPORTS.NS", "ULTRACEMCO.NS", "SHREECEM.NS", "GRASIM.NS"],
+    "Others": ["BHARTIARTL.NS", "ASIANPAINT.NS", "HDFCLIFE.NS", "SBILIFE.NS", "UPL.NS", 
+              "ADANIENT.NS", "BAJAJ-AUTO.NS", "APOLLOHOSP.NS", "DMART.NS", "PIDILITIND.NS"]
+}
+
+# Sector selection
+selected_sector = st.selectbox("Select Sector", list(sectors.keys()))
+
+# Load data for selected sector
+cols = st.columns(3)
+
+# Market Movers for selected sector
+with cols[0]:
+    st.subheader("Top Gainers")
+    gainers_data = []
+    for symbol in sectors[selected_sector]:
+        data = fetch_stock_data(symbol, period='1d')
+        if data is not None:
+            change = ((data['Close'][-1] - data['Open'][0]) / data['Open'][0]) * 100
+            info = get_stock_info(symbol)
+            company_name = info['name'] if info else symbol
+            gainers_data.append({
+                'Company': company_name,
+                'Symbol': symbol,
+                'Change%': change
+            })
+
+    # Sort gainers by change percentage
+    gainers_data = sorted(gainers_data, key=lambda x: x['Change%'], reverse=True)[:3]
+    st.dataframe(pd.DataFrame(gainers_data))
+
+with cols[1]:
+    st.subheader("Top Losers")
+    losers_data = []
+    for symbol in sectors[selected_sector]:
+        data = fetch_stock_data(symbol, period='1d')
+        if data is not None:
+            change = ((data['Close'][-1] - data['Open'][0]) / data['Open'][0]) * 100
+            info = get_stock_info(symbol)
+            company_name = info['name'] if info else symbol
+            losers_data.append({
+                'Company': company_name,
+                'Symbol': symbol,
+                'Change%': change
+            })
+
+    # Sort losers by change percentage
+    losers_data = sorted(losers_data, key=lambda x: x['Change%'])[:3]
+    st.dataframe(pd.DataFrame(losers_data))
+
+with cols[2]:
+    st.subheader("Most Active")
+    active_data = []
+    for symbol in sectors[selected_sector]:
+        info = get_stock_info(symbol)
+        if info:
+            active_data.append({
+                'Company': info['name'],
+                'Symbol': symbol,
+                'Volume': info['volume']
+            })
+
+    # Sort by volume
+    active_data = sorted(active_data, key=lambda x: x['Volume'], reverse=True)[:3]
+    st.dataframe(pd.DataFrame(active_data))
+
+# Sector Performance Heat Map
+st.subheader(f"{selected_sector} Performance Heat Map")
+heat_map_data = []
+for symbol in sectors[selected_sector]:
+    data = fetch_stock_data(symbol, period='1d')
+    info = get_stock_info(symbol)
+    if data is not None and info:
+        change = ((data['Close'][-1] - data['Open'][0]) / data['Open'][0]) * 100
+        heat_map_data.append({
+            'Company': info['name'],
+            'Symbol': symbol,
+            'Change%': change,
+            'Market Cap': info['market_cap'],
+            'Volume': info['volume']
+        })
+
+if heat_map_data:
+    fig = go.Figure(data=[go.Treemap(
+        labels=[f"{d['Company']}<br>{d['Symbol']}" for d in heat_map_data],
+        parents=[''] * len(heat_map_data),
+        values=[d['Market Cap'] for d in heat_map_data],
+        textinfo="label+value+percent",
+        marker=dict(
+            colors=[d['Change%'] for d in heat_map_data],
+            colorscale='RdYlGn',
+            showscale=True
+        ),
+        hovertemplate="""
+        Company: %{label}<br>
+        Change: %{color:.2f}%<br>
+        Market Cap: ₹%{value:,.0f}<br>
+        <extra></extra>
+        """
+    )])
+
+    fig.update_layout(title=f"{selected_sector} Companies Heat Map")
+    st.plotly_chart(fig, use_container_width=True)
+
+# Detailed Sector Analysis
+st.subheader(f"{selected_sector} Companies")
+detailed_data = []
+for symbol in sectors[selected_sector]:
+    info = get_stock_info(symbol)
+    if info:
+        detailed_data.append({
+            'Company': info['name'],
+            'Symbol': symbol,
+            'Market Cap (Cr)': info['market_cap'] / 10000000,  # Convert to Crores
+            'P/E Ratio': info['pe_ratio'],
+            'Volume': info['volume'],
+            'Recommendation': info['recommendation'],
+            'Target Price': info['target_price']
+        })
+
+if detailed_data:
+    st.dataframe(pd.DataFrame(detailed_data))

pages/predictions.py

@@ -0,0 +1,145 @@
+import streamlit as st
+import plotly.graph_objects as go
+import numpy as np
+from datetime import datetime, timedelta
+from utils.data_loader import load_nifty50_symbols, fetch_stock_data
+from utils.quantum_algorithms import QuantumInspiredOptimizer
+
+st.title("Market Predictions")
+
+# Initialize quantum optimizer
+quantum_optimizer = QuantumInspiredOptimizer()
+
+# Stock selection
+symbol = st.selectbox("Select Stock", load_nifty50_symbols())
+prediction_days = st.slider("Prediction Window (days)", 5, 30, 7)
+
+# Fetch data
+data = fetch_stock_data(symbol, period='1y')
+
+if data is not None:
+    prices = data['Close'].values
+    
+    # Calculate predictions
+    predictions = quantum_optimizer.quantum_trend_prediction(prices)
+    
+    # Create future dates for predictions
+    last_date = data.index[-1]
+    future_dates = [last_date + timedelta(days=x) for x in range(1, prediction_days + 1)]
+    
+    # Calculate confidence intervals (simple example)
+    confidence_high = predictions * 1.02
+    confidence_low = predictions * 0.98
+    
+    # Plotting
+    fig = go.Figure()
+    
+    # Historical prices
+    fig.add_trace(go.Scatter(
+        x=data.index,
+        y=data['Close'],
+        name='Historical Price',
+        line=dict(color='#00B894')
+    ))
+    
+    # Predictions
+    fig.add_trace(go.Scatter(
+        x=future_dates,
+        y=predictions[-prediction_days:],
+        name='Predicted Price',
+        line=dict(color='#FFA500', dash='dash')
+    ))
+    
+    # Confidence interval
+    fig.add_trace(go.Scatter(
+        x=future_dates,
+        y=confidence_high[-prediction_days:],
+        fill=None,
+        mode='lines',
+        line_color='rgba(255, 165, 0, 0)',
+        showlegend=False
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=future_dates,
+        y=confidence_low[-prediction_days:],
+        fill='tonexty',
+        mode='lines',
+        line_color='rgba(255, 165, 0, 0)',
+        name='Confidence Interval'
+    ))
+    
+    fig.update_layout(
+        title=f"Price Prediction for {symbol}",
+        xaxis_title="Date",
+        yaxis_title="Price",
+        height=600
+    )
+    
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Prediction metrics
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        predicted_change = (predictions[-1] - prices[-1]) / prices[-1] * 100
+        st.metric(
+            "Predicted Change",
+            f"{predicted_change:.2f}%",
+            delta=f"{predicted_change:.2f}%"
+        )
+    
+    with col2:
+        confidence_range = (confidence_high[-1] - confidence_low[-1]) / predictions[-1] * 100
+        st.metric(
+            "Confidence Range",
+            f"±{confidence_range:.2f}%"
+        )
+    
+    with col3:
+        trend = "Bullish" if predicted_change > 0 else "Bearish"
+        st.metric(
+            "Predicted Trend",
+            trend,
+            delta="↑" if predicted_change > 0 else "↓"
+        )
+    
+    # Additional analysis
+    st.subheader("Technical Factors")
+    
+    # Calculate some basic technical indicators for the prediction
+    momentum = np.gradient(predictions[-30:])
+    volatility = np.std(prices[-30:]) / np.mean(prices[-30:]) * 100
+    
+    factors_col1, factors_col2 = st.columns(2)
+    
+    with factors_col1:
+        st.markdown("""
+        ### Momentum Analysis
+        - Short-term trend: **{}**
+        - Momentum strength: **{:.2f}**
+        """.format(
+            "Positive" if momentum[-1] > 0 else "Negative",
+            abs(momentum[-1])
+        ))
+    
+    with factors_col2:
+        st.markdown("""
+        ### Risk Metrics
+        - Historical volatility: **{:.2f}%**
+        - Prediction confidence: **{:.2f}%**
+        """.format(
+            volatility,
+            100 - confidence_range
+        ))
+    
+    # Warning/Disclaimer
+    st.warning("""
+    **Disclaimer**: These predictions are based on quantum-inspired algorithms and historical data analysis.
+    Market behavior is inherently unpredictable and these projections should not be used as the sole basis
+    for investment decisions. Always conduct thorough research and consider multiple factors before making
+    investment choices.
+    """)
+
+else:
+    st.error("Unable to fetch data. Please try again later.")

pages/quantum_patterns.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import plotly.graph_objects as go
+import numpy as np
+from utils.data_loader import load_nifty50_symbols, fetch_stock_data
+from utils.quantum_algorithms import QuantumInspiredOptimizer
+
+st.title("Quantum Pattern Analysis")
+
+# Initialize quantum optimizer
+quantum_optimizer = QuantumInspiredOptimizer()
+
+# Stock selection
+symbol = st.selectbox("Select Stock", load_nifty50_symbols())
+timeframe = st.selectbox("Select Timeframe", ["1mo", "3mo", "6mo", "1y"])
+
+# Fetch data
+data = fetch_stock_data(symbol, period=timeframe)
+
+if data is not None:
+    # Create tabs for different quantum analyses
+    tab1, tab2, tab3 = st.tabs([
+        "Quantum Pattern Detection",
+        "Quantum Momentum",
+        "Quantum State Analysis"
+    ])
+
+    with tab1:
+        st.subheader("Quantum-Inspired Pattern Detection")
+        
+        # Calculate quantum patterns
+        prices = data['Close'].values
+        pattern_strength = quantum_optimizer.quantum_pattern_detection(prices)
+        
+        fig = go.Figure()
+        
+        # Price plot
+        fig.add_trace(go.Scatter(
+            x=data.index,
+            y=data['Close'],
+            name='Price',
+            line=dict(color='#00B894')
+        ))
+        
+        # Pattern strength
+        fig.add_trace(go.Scatter(
+            x=data.index,
+            y=pattern_strength[:len(data)],
+            name='Pattern Strength',
+            line=dict(color='#FFA500'),
+            yaxis='y2'
+        ))
+        
+        fig.update_layout(
+            title="Quantum Pattern Detection",
+            yaxis=dict(title="Price"),
+            yaxis2=dict(title="Pattern Strength", overlaying='y', side='right'),
+            height=600
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+
+    with tab2:
+        st.subheader("Quantum Momentum Indicator")
+        
+        # Calculate quantum momentum
+        momentum = quantum_optimizer.quantum_momentum_indicator(prices)
+        
+        fig = go.Figure()
+        
+        # Price plot
+        fig.add_trace(go.Scatter(
+            x=data.index,
+            y=data['Close'],
+            name='Price',
+            line=dict(color='#00B894')
+        ))
+        
+        # Momentum indicator
+        fig.add_trace(go.Scatter(
+            x=data.index,
+            y=momentum,
+            name='Quantum Momentum',
+            line=dict(color='#FF4757'),
+            yaxis='y2'
+        ))
+        
+        fig.update_layout(
+            title="Quantum Momentum Analysis",
+            yaxis=dict(title="Price"),
+            yaxis2=dict(title="Momentum", overlaying='y', side='right'),
+            height=600
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+
+    with tab3:
+        st.subheader("Quantum State Analysis")
+        
+        # Calculate quantum states
+        encoded_data = quantum_optimizer.quantum_inspired_encoding(prices)
+        amplitudes = np.abs(encoded_data)
+        phases = np.angle(encoded_data)
+        
+        # Create subplots
+        fig = go.Figure()
+        
+        # Amplitude plot
+        fig.add_trace(go.Scatter(
+            x=data.index,
+            y=amplitudes.flatten(),
+            name='Amplitude',
+            line=dict(color='#00B894')
+        ))
+        
+        # Phase plot
+        fig.add_trace(go.Scatter(
+            x=data.index,
+            y=phases.flatten(),
+            name='Phase',
+            line=dict(color='#FFA500'),
+            yaxis='y2'
+        ))
+        
+        fig.update_layout(
+            title="Quantum State Representation",
+            yaxis=dict(title="Amplitude"),
+            yaxis2=dict(title="Phase", overlaying='y', side='right'),
+            height=600
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Display quantum state statistics
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric(
+                "Average Amplitude",
+                f"{np.mean(amplitudes):.4f}"
+            )
+        
+        with col2:
+            st.metric(
+                "Phase Coherence",
+                f"{np.std(phases):.4f}"
+            )
+        
+        with col3:
+            st.metric(
+                "Quantum Entropy",
+                f"{-np.sum(amplitudes**2 * np.log(amplitudes**2 + 1e-10)):.4f}"
+            )
+
+else:
+    st.error("Unable to fetch data. Please try again later.")

pages/sentiment_heatmap.py

@@ -0,0 +1,214 @@
+import streamlit as st
+import plotly.graph_objects as go
+import pandas as pd
+import numpy as np
+from utils.data_loader import load_nifty50_symbols, fetch_stock_data, get_stock_info
+from utils.market_analysis import MarketAnalyzer
+import asyncio
+import json
+
+st.title("Market Sentiment Heatmap")
+
+# Initialize market analyzer
+market_analyzer = MarketAnalyzer()
+
+# Create tabs for different views
+tab1, tab2 = st.tabs(["Sector-wise Sentiment", "Stock-wise Sentiment"])
+
+with tab1:
+    st.subheader("Sector Sentiment Analysis")
+
+    # Define sectors and their stocks
+    sectors = {
+        "IT": ["TCS.NS", "INFY.NS", "HCLTECH.NS", "TECHM.NS", "WIPRO.NS"],
+        "Banking & Finance": ["HDFCBANK.NS", "ICICIBANK.NS", "SBIN.NS", "AXISBANK.NS", "KOTAKBANK.NS"],
+        "Energy & Oil": ["RELIANCE.NS", "ONGC.NS", "POWERGRID.NS", "NTPC.NS", "BPCL.NS"],
+        "Automobile": ["TATAMOTORS.NS", "M&M.NS", "MARUTI.NS", "HEROMOTOCO.NS"],
+        "Consumer Goods": ["HINDUNILVR.NS", "ITC.NS", "NESTLEIND.NS", "BRITANNIA.NS"],
+        "Metals & Mining": ["TATASTEEL.NS", "HINDALCO.NS", "JSWSTEEL.NS", "COALINDIA.NS"],
+        "Pharmaceuticals": ["SUNPHARMA.NS", "DRREDDY.NS", "CIPLA.NS", "DIVISLAB.NS"]
+    }
+
+    # Calculate sector sentiment
+    sector_data = {}
+
+    with st.spinner("Analyzing sector sentiment..."):
+        for sector, symbols in sectors.items():
+            valid_changes = []
+            for symbol in symbols:
+                try:
+                    data = fetch_stock_data(symbol, period='1d')
+                    if data is not None and not data.empty:
+                        change = ((data['Close'].iloc[-1] - data['Open'].iloc[0]) / data['Open'].iloc[0]) * 100
+                        valid_changes.append(change)
+                except Exception as e:
+                    continue
+
+            if valid_changes:
+                sector_data[sector] = np.mean(valid_changes)
+
+    if sector_data:
+        sectors = list(sector_data.keys())
+        values = list(sector_data.values())
+
+        fig = go.Figure(data=[go.Treemap(
+            labels=sectors,
+            parents=[''] * len(sectors),
+            values=[abs(v) for v in values],
+            textinfo="label+value+percent",
+            marker=dict(
+                colors=values,
+                colorscale='RdYlGn',
+                showscale=True,
+                colorbar=dict(title="Change %")
+            ),
+            hovertemplate="""
+            Sector: %{label}<br>
+            Average Change: %{color:.2f}%<br>
+            <extra></extra>
+            """
+        )])
+
+        fig.update_layout(
+            title="Sector-wise Market Sentiment",
+            width=800,
+            height=600
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Display sector statistics
+        st.subheader("Sector Performance")
+        sector_stats = pd.DataFrame({
+            'Sector': sectors,
+            'Average Change %': values
+        }).sort_values('Average Change %', ascending=False)
+
+        st.dataframe(sector_stats)
+    else:
+        st.warning("No sector data available. Please try again later.")
+
+with tab2:
+    st.subheader("Stock-wise Sentiment")
+
+    # Select sector for stock analysis
+    selected_sector = st.selectbox("Select Sector", list(sectors.keys()))
+
+    if selected_sector:
+        symbols = sectors[selected_sector]
+        stock_data = []
+
+        with st.spinner(f"Analyzing sentiment for {selected_sector} sector stocks..."):
+            for symbol in symbols:
+                try:
+                    # Get basic stock info
+                    info = get_stock_info(symbol)
+                    if info is None:
+                        st.warning(f"Could not fetch info for {symbol}")
+                        continue
+
+                    # Fetch stock data
+                    data = fetch_stock_data(symbol, period='5d')
+                    if data is None or data.empty:
+                        st.warning(f"Could not fetch data for {symbol}")
+                        continue
+
+                    # Get AI sentiment
+                    sentiment_response = await market_analyzer.get_ai_sentiment(symbol, data)
+
+                    if sentiment_response.startswith("Error"):
+                        st.error(f"Sentiment analysis error for {symbol}: {sentiment_response}")
+                        continue
+
+                    try:
+                        # Parse sentiment response
+                        sentiment_dict = json.loads(sentiment_response.replace("'", '"'))
+
+                        sentiment_score = {
+                            'bullish': 1,
+                            'neutral': 0,
+                            'bearish': -1
+                        }.get(str(sentiment_dict.get('sentiment', '')).lower(), 0)
+
+                        confidence = float(sentiment_dict.get('confidence', 0.5))
+                        final_score = sentiment_score * confidence
+
+                        stock_data.append({
+                            'name': info['name'],
+                            'symbol': symbol,
+                            'sentiment_score': final_score,
+                            'market_cap': info['market_cap'],
+                            'sentiment': sentiment_dict.get('sentiment', 'N/A'),
+                            'confidence': confidence,
+                            'recommendation': sentiment_dict.get('recommendation', 'N/A'),
+                            'risk_level': sentiment_dict.get('risk_level', 'N/A'),
+                            'key_factors': sentiment_dict.get('key_factors', [])
+                        })
+
+                    except json.JSONDecodeError as e:
+                        st.error(f"Error parsing sentiment data for {symbol}: {str(e)}")
+                        continue
+                    except Exception as e:
+                        st.error(f"Unexpected error processing {symbol}: {str(e)}")
+                        continue
+
+            if stock_data:
+                # Create heatmap
+                fig = go.Figure(data=[go.Treemap(
+                    labels=[f"{d['name']}<br>({d['symbol']})" for d in stock_data],
+                    parents=[''] * len(stock_data),
+                    values=[abs(d['market_cap']) for d in stock_data],
+                    textinfo="label",
+                    marker=dict(
+                        colors=[d['sentiment_score'] for d in stock_data],
+                        colorscale='RdYlGn',
+                        showscale=True,
+                        colorbar=dict(title="Sentiment Score")
+                    ),
+                    hovertemplate="""
+                    Company: %{label}<br>
+                    Sentiment Score: %{color:.2f}<br>
+                    Market Cap: ₹%{value:,.0f}<br>
+                    <extra></extra>
+                    """
+                )])
+
+                fig.update_layout(
+                    title=f"{selected_sector} Sector Sentiment Heatmap",
+                    width=800,
+                    height=600
+                )
+
+                st.plotly_chart(fig, use_container_width=True)
+
+                # Create summary table
+                st.subheader("Sentiment Summary")
+                summary_df = pd.DataFrame([{
+                    'Company': d['name'],
+                    'Symbol': d['symbol'],
+                    'Sentiment': d['sentiment'],
+                    'Confidence': f"{d['confidence']:.2f}",
+                    'Recommendation': d['recommendation'],
+                    'Risk Level': d['risk_level']
+                } for d in stock_data])
+
+                st.dataframe(summary_df)
+
+                # Show detailed insights
+                st.subheader("Detailed Analysis")
+                for stock in stock_data:
+                    with st.expander(f"{stock['name']} ({stock['symbol']})"):
+                        st.markdown(f"""
+                        **Sentiment:** {stock['sentiment']}  
+                        **Confidence:** {stock['confidence']:.2f}  
+                        **Recommendation:** {stock['recommendation']}  
+                        **Risk Level:** {stock['risk_level']}
+
+                        **Key Factors:**
+                        """)
+                        for factor in stock['key_factors']:
+                            st.markdown(f"- {factor}")
+            else:
+                st.warning("No sentiment data available. Please try again later.")
+    else:
+        st.info("Please select a sector to view stock-wise sentiment analysis.")

pages/technical_analysis.py

@@ -0,0 +1,171 @@
+import streamlit as st
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+from utils.data_loader import load_nifty50_symbols, fetch_stock_data
+from utils.technical_indicators import (
+    calculate_rsi,
+    calculate_macd,
+    calculate_bollinger_bands,
+    calculate_support_resistance
+)
+
+st.title("Technical Analysis")
+
+# Stock selection
+symbol = st.selectbox("Select Stock", load_nifty50_symbols())
+timeframe = st.selectbox(
+    "Select Timeframe",
+    options=["1w", "1mo", "3mo", "6mo", "1y", "3y", "5y"],
+    format_func=lambda x: {
+        "1w": "1 Week",
+        "1mo": "1 Month",
+        "3mo": "1 Quarter",
+        "6mo": "6 Months",
+        "1y": "1 Year",
+        "3y": "3 Years",
+        "5y": "5 Years"
+    }[x]
+)
+
+# Fetch data
+data = fetch_stock_data(symbol, period=timeframe)
+
+if data is not None:
+    # Create tabs for different analysis
+    tab1, tab2, tab3 = st.tabs(["Price & Volume", "Technical Indicators", "Support & Resistance"])
+
+    with tab1:
+        # Candlestick chart with volume
+        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, 
+                           vertical_spacing=0.03, 
+                           row_heights=[0.7, 0.3])
+
+        # Candlestick
+        fig.add_trace(go.Candlestick(
+            x=data.index,
+            open=data['Open'],
+            high=data['High'],
+            low=data['Low'],
+            close=data['Close'],
+            name='OHLC'
+        ), row=1, col=1)
+
+        # Volume
+        fig.add_trace(go.Bar(
+            x=data.index,
+            y=data['Volume'],
+            name='Volume',
+            marker_color='rgba(0,184,148,0.3)'
+        ), row=2, col=1)
+
+        fig.update_layout(
+            title=f"{symbol} Price and Volume",
+            yaxis_title="Price",
+            yaxis2_title="Volume",
+            xaxis_rangeslider_visible=False,
+            height=800
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+
+    with tab2:
+        # Technical indicators
+        col1, col2 = st.columns(2)
+
+        with col1:
+            # RSI
+            rsi = calculate_rsi(data)
+            fig_rsi = go.Figure()
+            fig_rsi.add_trace(go.Scatter(
+                x=data.index,
+                y=rsi,
+                name='RSI',
+                line=dict(color='#00B894')
+            ))
+            fig_rsi.add_hline(y=70, line_dash="dash", line_color="red")
+            fig_rsi.add_hline(y=30, line_dash="dash", line_color="green")
+            fig_rsi.update_layout(title="RSI (14)", height=400)
+            st.plotly_chart(fig_rsi, use_container_width=True)
+
+        with col2:
+            # MACD
+            macd, signal = calculate_macd(data)
+            fig_macd = go.Figure()
+            fig_macd.add_trace(go.Scatter(
+                x=data.index,
+                y=macd,
+                name='MACD',
+                line=dict(color='#00B894')
+            ))
+            fig_macd.add_trace(go.Scatter(
+                x=data.index,
+                y=signal,
+                name='Signal',
+                line=dict(color='#FFA500')
+            ))
+            fig_macd.update_layout(title="MACD", height=400)
+            st.plotly_chart(fig_macd, use_container_width=True)
+
+        # Bollinger Bands
+        upper_band, middle_band, lower_band = calculate_bollinger_bands(data)
+        fig_bb = go.Figure()
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=upper_band,
+            name='Upper Band',
+            line=dict(color='gray', dash='dash')
+        ))
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=middle_band,
+            name='Middle Band',
+            line=dict(color='blue')
+        ))
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=lower_band,
+            name='Lower Band',
+            line=dict(color='gray', dash='dash')
+        ))
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=data['Close'],
+            name='Close Price',
+            line=dict(color='#00B894')
+        ))
+        fig_bb.update_layout(title="Bollinger Bands", height=500)
+        st.plotly_chart(fig_bb, use_container_width=True)
+
+    with tab3:
+        # Support and Resistance
+        support, resistance = calculate_support_resistance(data)
+        fig_sr = go.Figure()
+
+        fig_sr.add_trace(go.Scatter(
+            x=data.index,
+            y=data['Close'],
+            name='Price',
+            line=dict(color='#00B894')
+        ))
+        fig_sr.add_trace(go.Scatter(
+            x=data.index,
+            y=support,
+            name='Support',
+            line=dict(color='green', dash='dash')
+        ))
+        fig_sr.add_trace(go.Scatter(
+            x=data.index,
+            y=resistance,
+            name='Resistance',
+            line=dict(color='red', dash='dash')
+        ))
+
+        fig_sr.update_layout(
+            title="Support and Resistance Levels",
+            height=600
+        )
+        st.plotly_chart(fig_sr, use_container_width=True)
+
+else:
+    st.error("Unable to fetch data. Please try again later.")

predictions.py

@@ -1,5 +1,5 @@
 import streamlit as st
-import matplotlib.pyplot as plt
+import plotly.graph_objects as go
 import numpy as np
 from datetime import datetime, timedelta
 from utils.data_loader import load_nifty50_symbols, fetch_stock_data
@@ -32,23 +32,51 @@ if data is not None:
     confidence_low = predictions * 0.98
     
     # Plotting
-    fig, ax = plt.subplots(figsize=(10, 5))
+    fig = go.Figure()
     
     # Historical prices
-    ax.plot(data.index, data['Close'], label='Historical Price', color='#00B894')
+    fig.add_trace(go.Scatter(
+        x=data.index,
+        y=data['Close'],
+        name='Historical Price',
+        line=dict(color='#00B894')
+    ))
     
     # Predictions
-    ax.plot(future_dates, predictions[-prediction_days:], label='Predicted Price', color='#FFA500', linestyle='dashed')
+    fig.add_trace(go.Scatter(
+        x=future_dates,
+        y=predictions[-prediction_days:],
+        name='Predicted Price',
+        line=dict(color='#FFA500', dash='dash')
+    ))
     
     # Confidence interval
-    ax.fill_between(future_dates, confidence_low[-prediction_days:], confidence_high[-prediction_days:], color='orange', alpha=0.2, label='Confidence Interval')
-    
-    ax.set_title(f"Price Prediction for {symbol}")
-    ax.set_xlabel("Date")
-    ax.set_ylabel("Price")
-    ax.legend()
+    fig.add_trace(go.Scatter(
+        x=future_dates,
+        y=confidence_high[-prediction_days:],
+        fill=None,
+        mode='lines',
+        line_color='rgba(255, 165, 0, 0)',
+        showlegend=False
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=future_dates,
+        y=confidence_low[-prediction_days:],
+        fill='tonexty',
+        mode='lines',
+        line_color='rgba(255, 165, 0, 0)',
+        name='Confidence Interval'
+    ))
+    
+    fig.update_layout(
+        title=f"Price Prediction for {symbol}",
+        xaxis_title="Date",
+        yaxis_title="Price",
+        height=600
+    )
     
-    st.pyplot(fig)
+    st.plotly_chart(fig, use_container_width=True)
     
     # Prediction metrics
     col1, col2, col3 = st.columns(3)
@@ -111,8 +139,7 @@ if data is not None:
     Market behavior is inherently unpredictable and these projections should not be used as the sole basis
     for investment decisions. Always conduct thorough research and consider multiple factors before making
     investment choices.
-    ""
-    )
+    """)
 
 else:
     st.error("Unable to fetch data. Please try again later.")

technical_analysis.py

@@ -1,5 +1,6 @@
 import streamlit as st
-import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 import pandas as pd
 from utils.data_loader import load_nifty50_symbols, fetch_stock_data
 from utils.technical_indicators import (
@@ -35,14 +36,38 @@ if data is not None:
     tab1, tab2, tab3 = st.tabs(["Price & Volume", "Technical Indicators", "Support & Resistance"])
 
     with tab1:
-        # Price Chart
-        fig, ax = plt.subplots(figsize=(10, 5))
-        ax.plot(data.index, data['Close'], label='Close Price', color='blue')
-        ax.set_title(f"{symbol} Price Over Time")
-        ax.set_xlabel("Date")
-        ax.set_ylabel("Price")
-        ax.legend()
-        st.pyplot(fig)
+        # Candlestick chart with volume
+        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, 
+                           vertical_spacing=0.03, 
+                           row_heights=[0.7, 0.3])
+
+        # Candlestick
+        fig.add_trace(go.Candlestick(
+            x=data.index,
+            open=data['Open'],
+            high=data['High'],
+            low=data['Low'],
+            close=data['Close'],
+            name='OHLC'
+        ), row=1, col=1)
+
+        # Volume
+        fig.add_trace(go.Bar(
+            x=data.index,
+            y=data['Volume'],
+            name='Volume',
+            marker_color='rgba(0,184,148,0.3)'
+        ), row=2, col=1)
+
+        fig.update_layout(
+            title=f"{symbol} Price and Volume",
+            yaxis_title="Price",
+            yaxis2_title="Volume",
+            xaxis_rangeslider_visible=False,
+            height=800
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
 
     with tab2:
         # Technical indicators
@@ -51,49 +76,96 @@ if data is not None:
         with col1:
             # RSI
             rsi = calculate_rsi(data)
-            fig_rsi, ax_rsi = plt.subplots(figsize=(10, 4))
-            ax_rsi.plot(data.index, rsi, label='RSI', color='green')
-            ax_rsi.axhline(70, linestyle="dashed", color="red", label="Overbought (70)")
-            ax_rsi.axhline(30, linestyle="dashed", color="blue", label="Oversold (30)")
-            ax_rsi.set_title("RSI (14)")
-            ax_rsi.set_xlabel("Date")
-            ax_rsi.legend()
-            st.pyplot(fig_rsi)
+            fig_rsi = go.Figure()
+            fig_rsi.add_trace(go.Scatter(
+                x=data.index,
+                y=rsi,
+                name='RSI',
+                line=dict(color='#00B894')
+            ))
+            fig_rsi.add_hline(y=70, line_dash="dash", line_color="red")
+            fig_rsi.add_hline(y=30, line_dash="dash", line_color="green")
+            fig_rsi.update_layout(title="RSI (14)", height=400)
+            st.plotly_chart(fig_rsi, use_container_width=True)
 
         with col2:
             # MACD
             macd, signal = calculate_macd(data)
-            fig_macd, ax_macd = plt.subplots(figsize=(10, 4))
-            ax_macd.plot(data.index, macd, label='MACD', color='blue')
-            ax_macd.plot(data.index, signal, label='Signal', color='orange')
-            ax_macd.set_title("MACD")
-            ax_macd.set_xlabel("Date")
-            ax_macd.legend()
-            st.pyplot(fig_macd)
+            fig_macd = go.Figure()
+            fig_macd.add_trace(go.Scatter(
+                x=data.index,
+                y=macd,
+                name='MACD',
+                line=dict(color='#00B894')
+            ))
+            fig_macd.add_trace(go.Scatter(
+                x=data.index,
+                y=signal,
+                name='Signal',
+                line=dict(color='#FFA500')
+            ))
+            fig_macd.update_layout(title="MACD", height=400)
+            st.plotly_chart(fig_macd, use_container_width=True)
 
         # Bollinger Bands
         upper_band, middle_band, lower_band = calculate_bollinger_bands(data)
-        fig_bb, ax_bb = plt.subplots(figsize=(10, 5))
-        ax_bb.plot(data.index, upper_band, label='Upper Band', color='gray', linestyle='dashed')
-        ax_bb.plot(data.index, middle_band, label='Middle Band', color='blue')
-        ax_bb.plot(data.index, lower_band, label='Lower Band', color='gray', linestyle='dashed')
-        ax_bb.plot(data.index, data['Close'], label='Close Price', color='green')
-        ax_bb.set_title("Bollinger Bands")
-        ax_bb.set_xlabel("Date")
-        ax_bb.legend()
-        st.pyplot(fig_bb)
+        fig_bb = go.Figure()
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=upper_band,
+            name='Upper Band',
+            line=dict(color='gray', dash='dash')
+        ))
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=middle_band,
+            name='Middle Band',
+            line=dict(color='blue')
+        ))
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=lower_band,
+            name='Lower Band',
+            line=dict(color='gray', dash='dash')
+        ))
+        fig_bb.add_trace(go.Scatter(
+            x=data.index,
+            y=data['Close'],
+            name='Close Price',
+            line=dict(color='#00B894')
+        ))
+        fig_bb.update_layout(title="Bollinger Bands", height=500)
+        st.plotly_chart(fig_bb, use_container_width=True)
 
     with tab3:
         # Support and Resistance
         support, resistance = calculate_support_resistance(data)
-        fig_sr, ax_sr = plt.subplots(figsize=(10, 5))
-        ax_sr.plot(data.index, data['Close'], label='Price', color='blue')
-        ax_sr.plot(data.index, support, label='Support', color='green', linestyle='dashed')
-        ax_sr.plot(data.index, resistance, label='Resistance', color='red', linestyle='dashed')
-        ax_sr.set_title("Support and Resistance Levels")
-        ax_sr.set_xlabel("Date")
-        ax_sr.legend()
-        st.pyplot(fig_sr)
+        fig_sr = go.Figure()
+
+        fig_sr.add_trace(go.Scatter(
+            x=data.index,
+            y=data['Close'],
+            name='Price',
+            line=dict(color='#00B894')
+        ))
+        fig_sr.add_trace(go.Scatter(
+            x=data.index,
+            y=support,
+            name='Support',
+            line=dict(color='green', dash='dash')
+        ))
+        fig_sr.add_trace(go.Scatter(
+            x=data.index,
+            y=resistance,
+            name='Resistance',
+            line=dict(color='red', dash='dash')
+        ))
+
+        fig_sr.update_layout(
+            title="Support and Resistance Levels",
+            height=600
+        )
+        st.plotly_chart(fig_sr, use_container_width=True)
 
 else:
     st.error("Unable to fetch data. Please try again later.")