Upload 4 files

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.")

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.")

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.")

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.")