Upload 10 files

utils/data_loader.py

@@ -0,0 +1,168 @@
+import yfinance as yf
+import pandas as pd
+import streamlit as st
+from datetime import datetime, timedelta
+import io
+
+@st.cache_data(ttl=3600)
+def load_nifty50_symbols():
+    """Load Nifty 50 symbols"""
+    symbols = [
+        # IT Sector
+        "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",
+
+        # Telecommunications
+        "BHARTIARTL.NS",
+
+        # Others
+        "ASIANPAINT.NS", "HDFCLIFE.NS", "SBILIFE.NS", "UPL.NS", "ADANIENT.NS",
+        "BAJAJ-AUTO.NS", "APOLLOHOSP.NS", "DMART.NS", "PIDILITIND.NS"
+    ]
+    return symbols
+
+@st.cache_data(ttl=3600)
+def load_market_indices():
+    """Load major Indian market indices"""
+    indices = {
+        "NIFTY 50": "^NSEI",
+        "SENSEX": "^BSESN",
+        "BANK NIFTY": "^NSEBANK",
+        "NIFTY IT": "NIFTYIT.NS",
+        "NIFTY PHARMA": "NIFTYPHARMA.NS",
+        "NIFTY AUTO": "NIFTYAUTO.NS",
+        "NIFTY FMCG": "NIFTYFMCG.NS",
+        "NIFTY METAL": "NIFTYMETAL.NS",
+        "BSE 500": "^BSEFTY",
+        "NSE 500": "NIFTY500.NS"
+    }
+    return indices
+
+def process_uploaded_file(uploaded_file):
+    """Process uploaded CSV/Excel file"""
+    try:
+        if uploaded_file.name.endswith('.csv'):
+            df = pd.read_csv(uploaded_file)
+        elif uploaded_file.name.endswith(('.xls', '.xlsx')):
+            df = pd.read_excel(uploaded_file)
+        else:
+            raise ValueError("Unsupported file format")
+
+        # Ensure required columns exist
+        required_columns = ['Date', 'Open', 'High', 'Low', 'Close', 'Volume']
+        if not all(col in df.columns for col in required_columns):
+            raise ValueError("Missing required columns")
+
+        # Convert Date column to datetime
+        df['Date'] = pd.to_datetime(df['Date'])
+        return df
+    except Exception as e:
+        st.error(f"Error processing file: {str(e)}")
+        return None
+
+@st.cache_data(ttl=3600)
+def fetch_stock_data(symbol, period='1y'):
+    """Fetch stock data from Yahoo Finance"""
+    try:
+        stock = yf.Ticker(symbol)
+        data = stock.history(period=period)
+        return data
+    except Exception as e:
+        st.error(f"Error fetching data for {symbol}: {str(e)}")
+        return None
+
+@st.cache_data(ttl=3600)
+def get_stock_info(symbol):
+    """Get stock information"""
+    try:
+        stock = yf.Ticker(symbol)
+        info = stock.info
+        return {
+            'name': info.get('longName', symbol),
+            'sector': info.get('sector', 'N/A'),
+            'market_cap': info.get('marketCap', 0),
+            'pe_ratio': info.get('trailingPE', 0),
+            'volume': info.get('volume', 0),
+            'recommendation': info.get('recommendationKey', 'N/A'),
+            'target_price': info.get('targetMeanPrice', 0)
+        }
+    except Exception as e:
+        st.error(f"Error fetching info for {symbol}: {str(e)}")
+        return None
+
+def get_market_summary():
+    """Get market summary for indices"""
+    try:
+        indices = load_market_indices()
+        summaries = {}
+
+        for name, symbol in indices.items():
+            ticker = yf.Ticker(symbol)
+            data = ticker.history(period='1d')
+
+            if not data.empty:
+                summaries[name] = {
+                    'index_value': data['Close'].iloc[-1],
+                    'change': data['Close'].iloc[-1] - data['Open'].iloc[0],
+                    'change_percent': ((data['Close'].iloc[-1] - data['Open'].iloc[0]) / data['Open'].iloc[0]) * 100
+                }
+
+        return summaries
+    except Exception as e:
+        st.error(f"Error fetching market summary: {str(e)}")
+        return None
+
+def get_stock_suggestions(data):
+    """Generate stock suggestions based on technical indicators"""
+    try:
+        # Simple moving averages
+        data['SMA20'] = data['Close'].rolling(window=20).mean()
+        data['SMA50'] = data['Close'].rolling(window=50).mean()
+
+        # Get latest values
+        current_price = data['Close'].iloc[-1]
+        sma20 = data['SMA20'].iloc[-1]
+        sma50 = data['SMA50'].iloc[-1]
+
+        # Generate suggestion
+        if sma20 > sma50:
+            trend = "BULLISH"
+            suggestion = "Consider buying. Price is above moving averages."
+        elif sma20 < sma50:
+            trend = "BEARISH"
+            suggestion = "Consider selling. Price is below moving averages."
+        else:
+            trend = "NEUTRAL"
+            suggestion = "Market is sideways. Wait for clear trend."
+
+        return {
+            'trend': trend,
+            'suggestion': suggestion,
+            'current_price': current_price,
+            'sma20': sma20,
+            'sma50': sma50
+        }
+    except Exception as e:
+        st.error(f"Error generating suggestions: {str(e)}")
+        return None

utils/market_analysis.py

@@ -0,0 +1,292 @@
+import numpy as np
+import pandas as pd
+from typing import Dict, Any
+import requests
+import os
+from datetime import datetime, timedelta
+
+class MarketAnalyzer:
+    def __init__(self):
+        self.risk_levels = {
+            'LOW': 'Conservative investment suitable for long-term holding',
+            'MEDIUM': 'Moderate risk with potential for both gains and losses',
+            'HIGH': 'High volatility, suitable for aggressive trading'
+        }
+        self.deepseek_api_key = os.environ.get("DEEPSEEK_API_KEY")
+        self.deepseek_api_url = "https://api.deepseek.com/v1/chat/completions"
+
+    def calculate_technical_indicators(self, data: pd.DataFrame) -> Dict[str, Any]:
+        """Calculate comprehensive technical indicators"""
+        try:
+            # Price-based indicators
+            data['SMA_20'] = data['Close'].rolling(window=20).mean()
+            data['SMA_50'] = data['Close'].rolling(window=50).mean()
+            data['SMA_200'] = data['Close'].rolling(window=200).mean()
+
+            # Relative Strength Index (RSI)
+            delta = data['Close'].diff()
+            gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+            loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+            rs = gain / loss
+            data['RSI'] = 100 - (100 / (1 + rs))
+
+            # MACD
+            exp1 = data['Close'].ewm(span=12, adjust=False).mean()
+            exp2 = data['Close'].ewm(span=26, adjust=False).mean()
+            data['MACD'] = exp1 - exp2
+            data['Signal_Line'] = data['MACD'].ewm(span=9, adjust=False).mean()
+
+            # Bollinger Bands
+            data['BB_middle'] = data['Close'].rolling(window=20).mean()
+            bb_std = data['Close'].rolling(window=20).std()
+            data['BB_upper'] = data['BB_middle'] + (bb_std * 2)
+            data['BB_lower'] = data['BB_middle'] - (bb_std * 2)
+
+            # Average True Range (ATR)
+            high_low = data['High'] - data['Low']
+            high_close = abs(data['High'] - data['Close'].shift())
+            low_close = abs(data['Low'] - data['Close'].shift())
+            ranges = pd.concat([high_low, high_close, low_close], axis=1)
+            true_range = ranges.max(axis=1)
+            data['ATR'] = true_range.rolling(window=14).mean()
+
+            # Volume indicators
+            data['Volume_SMA'] = data['Volume'].rolling(window=20).mean()
+            data['Volume_Rate'] = data['Volume'] / data['Volume_SMA']
+
+            return data
+        except Exception as e:
+            raise Exception(f"Error calculating technical indicators: {str(e)}")
+
+    def analyze_price_action(self, data: pd.DataFrame) -> Dict[str, Any]:
+        """Analyze recent price action and trends"""
+        try:
+            current_price = data['Close'].iloc[-1]
+            sma_20 = data['SMA_20'].iloc[-1]
+            sma_50 = data['SMA_50'].iloc[-1]
+            sma_200 = data['SMA_200'].iloc[-1]
+            rsi = data['RSI'].iloc[-1]
+            macd = data['MACD'].iloc[-1]
+            signal = data['Signal_Line'].iloc[-1]
+            volume_rate = data['Volume_Rate'].iloc[-1]
+
+            # Trend Analysis
+            short_term_trend = "BULLISH" if current_price > sma_20 else "BEARISH"
+            medium_term_trend = "BULLISH" if sma_20 > sma_50 else "BEARISH"
+            long_term_trend = "BULLISH" if sma_50 > sma_200 else "BEARISH"
+
+            # Momentum Analysis
+            momentum = {
+                'RSI': {
+                    'value': rsi,
+                    'signal': 'OVERBOUGHT' if rsi > 70 else 'OVERSOLD' if rsi < 30 else 'NEUTRAL'
+                },
+                'MACD': {
+                    'histogram': macd - signal,
+                    'signal': 'BULLISH' if macd > signal else 'BEARISH'
+                }
+            }
+
+            # Volume Analysis
+            volume_trend = "HIGH" if volume_rate > 1.5 else "LOW" if volume_rate < 0.5 else "NORMAL"
+
+            return {
+                'trends': {
+                    'short_term': short_term_trend,
+                    'medium_term': medium_term_trend,
+                    'long_term': long_term_trend
+                },
+                'momentum': momentum,
+                'volume_analysis': {
+                    'trend': volume_trend,
+                    'rate': volume_rate
+                }
+            }
+        except Exception as e:
+            raise Exception(f"Error analyzing price action: {str(e)}")
+
+    def generate_trade_signals(self, data: pd.DataFrame) -> Dict[str, Any]:
+        """Generate trading signals based on technical analysis"""
+        try:
+            analysis = self.analyze_price_action(data)
+            current_price = data['Close'].iloc[-1]
+
+            # Signal Strength Calculation
+            bullish_signals = 0
+            bearish_signals = 0
+
+            # Trend Signals
+            for trend in analysis['trends'].values():
+                if trend == "BULLISH":
+                    bullish_signals += 1
+                else:
+                    bearish_signals += 1
+
+            # Momentum Signals
+            if analysis['momentum']['RSI']['signal'] == 'OVERSOLD':
+                bullish_signals += 1
+            elif analysis['momentum']['RSI']['signal'] == 'OVERBOUGHT':
+                bearish_signals += 1
+
+            if analysis['momentum']['MACD']['signal'] == 'BULLISH':
+                bullish_signals += 1
+            else:
+                bearish_signals += 1
+
+            # Volume Confirmation
+            if analysis['volume_analysis']['trend'] == 'HIGH':
+                if bullish_signals > bearish_signals:
+                    bullish_signals += 1
+                else:
+                    bearish_signals += 1
+
+            # Risk Assessment
+            volatility = data['ATR'].iloc[-1] / current_price * 100
+            risk_level = 'HIGH' if volatility > 3 else 'MEDIUM' if volatility > 1.5 else 'LOW'
+
+            # Generate Action Signal
+            signal_strength = (bullish_signals - bearish_signals) / (bullish_signals + bearish_signals)
+
+            if abs(signal_strength) < 0.2:
+                action = "HOLD"
+                confidence = "LOW"
+            else:
+                action = "BUY" if signal_strength > 0 else "SELL"
+                confidence = "HIGH" if abs(signal_strength) > 0.6 else "MEDIUM"
+
+            return {
+                'action': action,
+                'confidence': confidence,
+                'risk_level': risk_level,
+                'support_resistance': {
+                    'support': data['BB_lower'].iloc[-1],
+                    'resistance': data['BB_upper'].iloc[-1]
+                },
+                'metrics': {
+                    'bullish_signals': bullish_signals,
+                    'bearish_signals': bearish_signals,
+                    'volatility': volatility
+                }
+            }
+        except Exception as e:
+            raise Exception(f"Error generating trade signals: {str(e)}")
+
+    async def get_ai_sentiment(self, symbol: str, price_data: pd.DataFrame) -> str:
+        """Get AI-powered market sentiment analysis using Deepseek API"""
+        try:
+            if not self.deepseek_api_key:
+                return "Error: Deepseek API key not found"
+
+            # Prepare market data summary
+            recent_data = price_data.tail(5)
+            price_change = (recent_data['Close'].iloc[-1] - recent_data['Close'].iloc[0]) / recent_data['Close'].iloc[0] * 100
+            volume_change = (recent_data['Volume'].iloc[-1] - recent_data['Volume'].iloc[0]) / recent_data['Volume'].iloc[0] * 100
+            rsi = self.calculate_rsi(price_data['Close'])[-1] if not price_data.empty else None
+
+            # Create prompt for Deepseek
+            prompt = f"""Analyze the following market data for {symbol}:
+            - Recent price change: {price_change:.2f}%
+            - Volume change: {volume_change:.2f}%
+            - RSI: {rsi:.2f if rsi is not None else 'N/A'}
+
+            Please provide a JSON response with the following structure:
+            {{
+                "sentiment": "bullish/bearish/neutral",
+                "confidence": <float between 0 and 1>,
+                "recommendation": "buy/sell/hold",
+                "risk_level": "low/medium/high",
+                "key_factors": [<array of reasons>]
+            }}"""
+
+            # Call Deepseek API
+            headers = {
+                "Authorization": f"Bearer {self.deepseek_api_key}",
+                "Content-Type": "application/json"
+            }
+
+            payload = {
+                "model": "deepseek-chat",
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": "You are an expert financial analyst. Provide market analysis in the exact JSON format requested."
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                "temperature": 0.7,
+                "max_tokens": 500
+            }
+
+            response = requests.post(
+                self.deepseek_api_url,
+                headers=headers,
+                json=payload,
+                timeout=10
+            )
+
+            if response.status_code != 200:
+                return f"API Error: {response.status_code} - {response.text}"
+
+            # Extract the response content
+            try:
+                result = response.json()
+                if 'choices' in result and len(result['choices']) > 0:
+                    return result['choices'][0]['message']['content']
+                else:
+                    return "Error: Invalid API response format"
+            except Exception as e:
+                return f"Error parsing API response: {str(e)}"
+
+        except Exception as e:
+            return f"Error in sentiment analysis: {str(e)}"
+
+    def calculate_rsi(self, prices: pd.Series, period: int = 14) -> pd.Series:
+        """Calculate Relative Strength Index"""
+        delta = prices.diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+        rs = gain / loss
+        return 100 - (100 / (1 + rs))
+
+    def generate_detailed_report(self, symbol: str, data: pd.DataFrame, ai_sentiment: str = None) -> Dict[str, Any]:
+        """Generate comprehensive analysis report"""
+        try:
+            # Calculate all indicators
+            data = self.calculate_technical_indicators(data)
+
+            # Get trading signals
+            signals = self.generate_trade_signals(data)
+
+            # Price analysis
+            current_price = data['Close'].iloc[-1]
+            price_change_1d = (current_price - data['Close'].iloc[-2]) / data['Close'].iloc[-2] * 100
+            price_change_1w = (current_price - data['Close'].iloc[-6]) / data['Close'].iloc[-6] * 100
+
+            report = {
+                'symbol': symbol,
+                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                'price_analysis': {
+                    'current_price': current_price,
+                    'changes': {
+                        '1d': price_change_1d,
+                        '1w': price_change_1w
+                    }
+                },
+                'technical_analysis': self.analyze_price_action(data),
+                'trade_signals': signals,
+                'risk_assessment': {
+                    'level': signals['risk_level'],
+                    'description': self.risk_levels[signals['risk_level']],
+                    'volatility': signals['metrics']['volatility']
+                }
+            }
+
+            if ai_sentiment:
+                report['ai_sentiment'] = ai_sentiment
+
+            return report
+        except Exception as e:
+            raise Exception(f"Error generating detailed report: {str(e)}")

utils/portfolio_manager.py

@@ -0,0 +1,111 @@
+import pandas as pd
+import numpy as np
+from typing import List, Dict, Optional
+from utils.quantum_algorithms import QuantumInspiredOptimizer
+from utils.data_loader import fetch_stock_data
+
+class PortfolioManager:
+    def __init__(self):
+        self.quantum_optimizer = QuantumInspiredOptimizer()
+        self.watchlists = {}  # User watchlists
+        self.portfolios = {}  # User portfolios
+
+    def create_watchlist(self, user_id: str, name: str) -> Dict:
+        """Create a new watchlist for a user"""
+        if user_id not in self.watchlists:
+            self.watchlists[user_id] = {}
+        
+        self.watchlists[user_id][name] = []
+        return {'status': 'success', 'message': f'Watchlist {name} created'}
+
+    def add_to_watchlist(self, user_id: str, watchlist_name: str, symbol: str) -> Dict:
+        """Add a symbol to a watchlist"""
+        if user_id in self.watchlists and watchlist_name in self.watchlists[user_id]:
+            if symbol not in self.watchlists[user_id][watchlist_name]:
+                self.watchlists[user_id][watchlist_name].append(symbol)
+            return {'status': 'success', 'message': f'Added {symbol} to watchlist'}
+        return {'status': 'error', 'message': 'Watchlist not found'}
+
+    def get_watchlist(self, user_id: str, watchlist_name: str) -> List[Dict]:
+        """Get watchlist with current prices and analysis"""
+        if user_id not in self.watchlists or watchlist_name not in self.watchlists[user_id]:
+            return []
+
+        watchlist_data = []
+        for symbol in self.watchlists[user_id][watchlist_name]:
+            data = fetch_stock_data(symbol, period='1d')
+            if data is not None:
+                current_price = data['Close'].iloc[-1]
+                change = ((current_price - data['Open'].iloc[0]) / data['Open'].iloc[0]) * 100
+                
+                watchlist_data.append({
+                    'symbol': symbol,
+                    'current_price': current_price,
+                    'change_percent': change,
+                    'last_updated': data.index[-1].strftime('%Y-%m-%d %H:%M:%S')
+                })
+
+        return watchlist_data
+
+    def optimize_portfolio(self, symbols: List[str], risk_tolerance: float = 0.5) -> Dict:
+        """Optimize portfolio allocation using quantum-inspired algorithm"""
+        # Fetch historical data for all symbols
+        data = {}
+        for symbol in symbols:
+            hist_data = fetch_stock_data(symbol, period='1y')
+            if hist_data is not None:
+                data[symbol] = hist_data['Close']
+
+        if not data:
+            return {'status': 'error', 'message': 'No data available for optimization'}
+
+        # Calculate returns
+        returns = pd.DataFrame(data).pct_change().dropna()
+
+        # Get optimal weights
+        weights = self.quantum_optimizer.optimize_portfolio(returns, risk_tolerance)
+
+        # Calculate portfolio metrics
+        portfolio_return = sum(weights[symbol] * returns[symbol].mean() for symbol in symbols)
+        portfolio_risk = np.sqrt(sum(sum(
+            weights[s1] * weights[s2] * returns[s1].cov(returns[s2])
+            for s2 in symbols) for s1 in symbols))
+
+        return {
+            'status': 'success',
+            'allocation': weights,
+            'metrics': {
+                'expected_return': portfolio_return * 100,  # Convert to percentage
+                'risk': portfolio_risk * 100,  # Convert to percentage
+                'sharpe_ratio': portfolio_return / portfolio_risk if portfolio_risk > 0 else 0
+            }
+        }
+
+    def analyze_portfolio(self, portfolio: Dict[str, float]) -> Dict:
+        """Analyze current portfolio performance and suggest rebalancing"""
+        symbols = list(portfolio.keys())
+        current_weights = list(portfolio.values())
+        
+        # Get optimal weights
+        optimal_allocation = self.optimize_portfolio(symbols)
+        
+        if optimal_allocation['status'] == 'error':
+            return optimal_allocation
+
+        # Compare current vs optimal allocation
+        rebalancing_needed = any(
+            abs(portfolio[symbol] - optimal_allocation['allocation'][symbol]) > 0.05
+            for symbol in symbols
+        )
+
+        return {
+            'status': 'success',
+            'current_allocation': portfolio,
+            'optimal_allocation': optimal_allocation['allocation'],
+            'metrics': optimal_allocation['metrics'],
+            'rebalancing_needed': rebalancing_needed,
+            'rebalancing_suggestions': {
+                symbol: optimal_allocation['allocation'][symbol] - portfolio[symbol]
+                for symbol in symbols
+            } if rebalancing_needed else {}
+        }

utils/quantum_algorithms.py

@@ -0,0 +1,131 @@
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+from typing import List, Dict, Tuple
+import pandas as pd
+
+class QuantumInspiredOptimizer:
+    def __init__(self, n_qubits=4, iterations=100):
+        self.n_qubits = n_qubits
+        self.iterations = iterations
+        self.scaler = MinMaxScaler()
+
+    def quantum_inspired_encoding(self, data):
+        """Convert classical data into quantum-inspired representation"""
+        scaled_data = self.scaler.fit_transform(data.reshape(-1, 1))
+        phase = 2 * np.pi * scaled_data
+        return np.exp(1j * phase)
+
+    def quantum_pattern_detection(self, prices):
+        """Detect patterns using quantum-inspired interference"""
+        encoded_data = self.quantum_inspired_encoding(prices)
+        amplitudes = np.abs(encoded_data)
+        phases = np.angle(encoded_data)
+
+        # Pattern detection through interference
+        interference_pattern = np.convolve(amplitudes.flatten(), np.exp(1j * phases.flatten()))
+        return np.abs(interference_pattern[:len(prices)])
+
+    def quantum_momentum_indicator(self, prices, window=14):
+        """Calculate quantum-inspired momentum indicator"""
+        encoded_data = self.quantum_inspired_encoding(prices)
+        momentum = np.zeros(len(prices))
+
+        for i in range(window, len(prices)):
+            quantum_state = encoded_data[i-window:i]
+            interference = np.sum(quantum_state * np.conjugate(quantum_state))
+            momentum[i] = np.abs(interference)
+
+        return momentum
+
+    def quantum_trend_prediction(self, prices, lookback=5):
+        """Predict trend using quantum-inspired algorithm"""
+        encoded_data = self.quantum_inspired_encoding(prices)
+        predictions = np.zeros(len(prices))
+
+        for i in range(lookback, len(prices)):
+            quantum_state = encoded_data[i-lookback:i]
+            superposition = np.sum(quantum_state) / np.sqrt(lookback)
+            predictions[i] = np.abs(superposition)
+
+        return self.scaler.inverse_transform(predictions.reshape(-1, 1)).flatten()
+
+    def optimize_portfolio(self, returns: pd.DataFrame, risk_tolerance: float = 0.5) -> Dict[str, float]:
+        """Quantum-inspired portfolio optimization"""
+        n_assets = returns.shape[1]
+
+        # Initialize quantum-inspired particles
+        n_particles = 100
+        particles = np.random.rand(n_particles, n_assets)
+        particles = particles / particles.sum(axis=1)[:, np.newaxis]
+
+        # Calculate returns and risks
+        portfolio_returns = np.dot(particles, returns.mean().values)
+        covariance = returns.cov().values
+        portfolio_risks = np.sqrt(np.diagonal(np.dot(np.dot(particles, covariance), particles.T)))
+
+        # Quantum interference optimization
+        for _ in range(self.iterations):
+            # Quantum phase estimation
+            phases = 2 * np.pi * (portfolio_returns - portfolio_risks * risk_tolerance)
+            quantum_states = np.exp(1j * phases.reshape(-1, 1))
+
+            # Interference effect
+            interference = np.sum(quantum_states * np.conjugate(quantum_states))
+            best_idx = np.argmax(np.abs(interference))
+
+            # Update particles
+            particles = particles * np.exp(1j * phases.reshape(-1, 1))
+            particles = np.abs(particles)
+            particles = particles / particles.sum(axis=1)[:, np.newaxis]
+
+        # Select best portfolio weights
+        best_weights = particles[best_idx]
+
+        return {
+            asset: weight for asset, weight in zip(returns.columns, best_weights)
+        }
+
+    def detect_quantum_patterns(self, prices: np.ndarray) -> List[Dict[str, any]]:
+        """Advanced pattern detection using quantum interference"""
+        encoded_data = self.quantum_inspired_encoding(prices)
+        patterns = []
+
+        # Sliding window analysis
+        window_sizes = [5, 10, 20]
+        for window in window_sizes:
+            for i in range(window, len(prices)):
+                quantum_state = encoded_data[i-window:i]
+                interference = np.sum(quantum_state * np.conjugate(quantum_state))
+
+                # Pattern strength and type detection
+                pattern_strength = np.abs(interference)
+                phase_coherence = np.angle(interference)
+
+                if pattern_strength > 1.5:  # Significant pattern threshold
+                    pattern_type = "Bullish" if phase_coherence > 0 else "Bearish"
+                    patterns.append({
+                        'type': pattern_type,
+                        'strength': float(pattern_strength),
+                        'position': i,
+                        'window': window
+                    })
+
+        return patterns
+
+    def quantum_risk_assessment(self, prices: np.ndarray, volumes: np.ndarray) -> Dict[str, float]:
+        """Quantum-inspired risk assessment"""
+        price_encoded = self.quantum_inspired_encoding(prices)
+        volume_encoded = self.quantum_inspired_encoding(volumes)
+
+        # Quantum interference between price and volume
+        interference = np.sum(price_encoded * np.conjugate(volume_encoded))
+
+        # Calculate risk metrics
+        volatility = np.std(prices) / np.mean(prices)
+        volume_impact = np.abs(interference) / len(prices)
+
+        return {
+            'volatility': float(volatility),
+            'volume_impact': float(volume_impact),
+            'risk_score': float(np.sqrt(volatility * volume_impact))
+        }

utils/technical_indicators.py

@@ -0,0 +1,32 @@
+import numpy as np
+import pandas as pd
+
+def calculate_rsi(data, periods=14):
+    """Calculate Relative Strength Index"""
+    delta = data['Close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=periods).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=periods).mean()
+    rs = gain / loss
+    return 100 - (100 / (1 + rs))
+
+def calculate_macd(data):
+    """Calculate MACD"""
+    exp1 = data['Close'].ewm(span=12, adjust=False).mean()
+    exp2 = data['Close'].ewm(span=26, adjust=False).mean()
+    macd = exp1 - exp2
+    signal = macd.ewm(span=9, adjust=False).mean()
+    return macd, signal
+
+def calculate_bollinger_bands(data, window=20):
+    """Calculate Bollinger Bands"""
+    sma = data['Close'].rolling(window=window).mean()
+    std = data['Close'].rolling(window=window).std()
+    upper_band = sma + (std * 2)
+    lower_band = sma - (std * 2)
+    return upper_band, sma, lower_band
+
+def calculate_support_resistance(data, window=20):
+    """Calculate Support and Resistance levels"""
+    high_rolling = data['High'].rolling(window=window).max()
+    low_rolling = data['Low'].rolling(window=window).min()
+    return low_rolling, high_rolling