Upload 16 files

.env

@@ -0,0 +1,2 @@
+SWARMS_API_KEY=sk-f763a9c6f898aa3ec74bf49047736a0201c293eefc36d5a04be8af647b93b711
+FRED_API_KEY=d421178827e3d9c621210bc6f0303439

.gitignore

@@ -0,0 +1 @@
+__pycache__/

README.md

@@ -1,10 +0,0 @@
----
-title: Financial Analyst
-emoji: 🚀
-colorFrom: red
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,7 +1,120 @@
-from fastapi import FastAPI
-
-app = FastAPI()
-
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
+# main.py
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware # If Streamlit runs on a different port
+from typing import Dict, List
+from services.data_fetcher import IndianMarketDataFetcher
+from services.analyzer import IndianFinancialAnalyzer
+from services.swarm_service import create_indian_market_swarm
+from models.market_data import StockDataResponse, IndexData, SectorPerformance, EconomicIndicators
+from models.analysis import StockAnalysisResponse, SwarmAnalysisResponse, InvestmentRecommendationResponse
+from config import NIFTY50_COMPANIES
+
+app = FastAPI(title="Indian Market Analysis API", version="1.0.0")
+
+# Configure CORS if needed (e.g., if Streamlit runs on localhost:8501)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # Restrict this in production!
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Dependency Injection for services
+def get_data_fetcher():
+    return IndianMarketDataFetcher()
+
+def get_analyzer():
+    return IndianFinancialAnalyzer()
+
+# --- API Endpoints ---
+
+@app.get("/")
+async def root():
+    return {"message": "Indian Market Analysis API"}
+
+# --- Market Data Endpoints ---
+
+@app.get("/api/market/indices", response_model=Dict[str, IndexData])
+async def get_market_indices(fetcher: IndianMarketDataFetcher = Depends(get_data_fetcher)):
+    """Get live market indices data."""
+    return fetcher.get_market_indices()
+
+@app.get("/api/market/sectors", response_model=Dict[str, SectorPerformance])
+async def get_sector_performance(fetcher: IndianMarketDataFetcher = Depends(get_data_fetcher)):
+    """Get sector performance data."""
+    return fetcher.get_sector_performance()
+
+@app.get("/api/market/economic", response_model=EconomicIndicators)
+async def get_economic_indicators(analyzer: IndianFinancialAnalyzer = Depends(get_analyzer)):
+    """Get key economic indicators."""
+    return EconomicIndicators(
+        repo_rate=analyzer.rbi_repo_rate,
+        inflation_rate=analyzer.indian_inflation_rate
+    )
+
+# --- Stock Data Endpoints ---
+
+@app.get("/api/stocks/list", response_model=Dict[str, str])
+async def get_nifty50_list(fetcher: IndianMarketDataFetcher = Depends(get_data_fetcher)):
+    """Get the list of Nifty 50 companies."""
+    return fetcher.get_nifty50_companies()
+
+@app.get("/api/stocks/{symbol}", response_model=StockDataResponse)
+async def get_stock_data(symbol: str, period: str = "1y", fetcher: IndianMarketDataFetcher = Depends(get_data_fetcher)):
+    """Get detailed stock data for a given symbol."""
+    stock_data = fetcher.get_stock_data(symbol, period)
+    if not stock_data:
+        raise HTTPException(status_code=404, detail=f"Data for stock symbol {symbol} could not be fetched.")
+    return stock_data
+
+# --- Analysis Endpoints ---
+
+@app.post("/api/analysis/stock/{symbol}", response_model=StockAnalysisResponse)
+async def analyze_stock(symbol: str, period: str = "1y",
+                        fetcher: IndianMarketDataFetcher = Depends(get_data_fetcher),
+                        analyzer: IndianFinancialAnalyzer = Depends(get_analyzer)):
+    """Perform basic financial analysis on a stock."""
+    stock_data = fetcher.get_stock_data(symbol, period)
+    if not stock_data:
+        raise HTTPException(status_code=404, detail=f"Data for stock symbol {symbol} could not be fetched.")
+
+    company_name = NIFTY50_COMPANIES.get(symbol, symbol)
+    return analyzer.analyze_indian_stock(stock_data, company_name)
+
+@app.post("/api/analysis/swarm/{symbol}", response_model=SwarmAnalysisResponse)
+async def run_swarm_analysis(symbol: str, period: str = "1y",
+                             fetcher: IndianMarketDataFetcher = Depends(get_data_fetcher),
+                             analyzer: IndianFinancialAnalyzer = Depends(get_analyzer)):
+    """Run AI swarm analysis on a stock."""
+    stock_data = fetcher.get_stock_data(symbol, period)
+    if not stock_data:
+        return SwarmAnalysisResponse(status="error", error=f"Data for stock symbol {symbol} could not be fetched.")
+
+    company_name = NIFTY50_COMPANIES.get(symbol, symbol)
+
+    # Perform basic analysis first
+    basic_analysis_response = analyzer.analyze_indian_stock(stock_data, company_name)
+    basic_analysis_text = basic_analysis_response.basic_analysis
+
+    # Prepare data for swarm analysis
+    market_data_summary = f"""
+Stock: {company_name} ({symbol})
+Current Price: ₹{stock_data.history.get('Close', [0])[-1] if stock_data.history.get('Close') else 'N/A'}
+Market Data Analysis: {basic_analysis_text}
+"""
+
+    # Run swarm analysis
+    return create_indian_market_swarm(market_data_summary, company_name)
+
+@app.get("/api/analysis/recommendation", response_model=InvestmentRecommendationResponse)
+async def get_investment_recommendation(analyzer: IndianFinancialAnalyzer = Depends(get_analyzer)):
+    """Get general investment recommendations."""
+    return analyzer.generate_investment_recommendation()
+
+# --- Utility Endpoints ---
+
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "ok"}

config.py

@@ -0,0 +1,60 @@
+# config.py
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# API Keys
+SWARMS_API_KEY = os.getenv("SWARMS_API_KEY")
+FRED_API_KEY = os.getenv("FRED_API_KEY")
+
+# API URLs
+SWARMS_BASE_URL = "https://api.swarms.world"
+FRED_BASE_URL = "https://api.stlouisfed.org/fred/series/observations"
+
+# Default Values
+DEFAULT_REPO_RATE = 6.5
+DEFAULT_INFLATION_RATE = 5.7
+
+# Nifty 50 Companies (could be moved to a separate file if too large)
+NIFTY50_COMPANIES = {
+    'ADANIENT.NS': 'Adani Enterprises', 'ADANIPORTS.NS': 'Adani Ports',
+    'APOLLOHOSP.NS': 'Apollo Hospitals', 'ASIANPAINT.NS': 'Asian Paints',
+    'AXISBANK.NS': 'Axis Bank', 'BAJAJ-AUTO.NS': 'Bajaj Auto',
+    'BAJFINANCE.NS': 'Bajaj Finance', 'BAJAJFINSV.NS': 'Bajaj Finserv',
+    'BEL.NS': 'Bharat Electronics', 'BHARTIARTL.NS': 'Bharti Airtel',
+    'CIPLA.NS': 'Cipla', 'COALINDIA.NS': 'Coal India', 'DRREDDY.NS': 'Dr Reddy Labs',
+    'EICHERMOT.NS': 'Eicher Motors', 'GRASIM.NS': 'Grasim Industries',
+    'HCLTECH.NS': 'HCL Technologies', 'HDFCBANK.NS': 'HDFC Bank',
+    'HDFCLIFE.NS': 'HDFC Life', 'HEROMOTOCO.NS': 'Hero MotoCorp',
+    'HINDALCO.NS': 'Hindalco', 'HINDUNILVR.NS': 'Hindustan Unilever',
+    'ICICIBANK.NS': 'ICICI Bank', 'INDUSINDBK.NS': 'IndusInd Bank',
+    'INFY.NS': 'Infosys', 'ITC.NS': 'ITC', 'JIOFIN.NS': 'Jio Financial',
+    'JSWSTEEL.NS': 'JSW Steel', 'KOTAKBANK.NS': 'Kotak Mahindra Bank',
+    'LT.NS': 'Larsen & Toubro', 'M&M.NS': 'Mahindra & Mahindra',
+    'MARUTI.NS': 'Maruti Suzuki', 'NESTLEIND.NS': 'Nestle India',
+    'NTPC.NS': 'NTPC', 'ONGC.NS': 'ONGC', 'POWERGRID.NS': 'Power Grid Corp',
+    'RELIANCE.NS': 'Reliance Industries', 'SBILIFE.NS': 'SBI Life',
+    'SHRIRAMFIN.NS': 'Shriram Finance', 'SBIN.NS': 'State Bank of India',
+    'SUNPHARMA.NS': 'Sun Pharma', 'TATACONSUM.NS': 'Tata Consumer',
+    'TCS.NS': 'Tata Consultancy Services', 'TATAMOTORS.NS': 'Tata Motors',
+    'TATASTEEL.NS': 'Tata Steel', 'TECHM.NS': 'Tech Mahindra',
+    'TITAN.NS': 'Titan Company', 'TRENT.NS': 'Trent',
+    'ULTRACEMCO.NS': 'UltraTech Cement', 'WIPRO.NS': 'Wipro'
+}
+
+# Sector ETFs
+SECTOR_ETFS = {
+    'BANKBEES.NS': 'Banking',
+    'ITBEES.NS': 'IT',
+    'PHARMABEES.NS': 'Pharma',
+    'AUTOBEES.NS': 'Auto',
+    'NIFTYBEES.NS': 'Metal' # Note: This is Nifty 50 ETF, not Metal. You might want a proper Metal ETF.
+}
+
+# Market Indices
+MARKET_INDICES = {
+    '^NSEI': 'Nifty 50',
+    '^BSESN': 'BSE Sensex',
+    'NIFTY_MIDCAP_100.NS': 'Nifty Midcap 100'
+}

models/analysis.py

@@ -0,0 +1,19 @@
+# models/analysis.py
+from pydantic import BaseModel
+from typing import List, Optional
+
+class StockAnalysisResponse(BaseModel):
+    basic_analysis: str
+    # Add fields for more structured analysis if needed
+
+class SwarmAgentOutput(BaseModel):
+    role: str
+    content: str
+
+class SwarmAnalysisResponse(BaseModel):
+    status: str # 'success' or 'error'
+    output: Optional[List[SwarmAgentOutput]] = None
+    error: Optional[str] = None
+
+class InvestmentRecommendationResponse(BaseModel):
+    recommendation: str

models/market_data.py

@@ -0,0 +1,25 @@
+# models/market_data.py
+from pydantic import BaseModel
+from typing import  Dict, Any, List
+import pandas as pd
+
+class StockDataResponse(BaseModel):
+    history: Dict[str, Any] # Simplified, consider serializing DataFrame properly
+    info: Dict[str, Any]
+    financials: List[Dict[str, Any]] # List of records for financials
+    balance_sheet: List[Dict[str, Any]] # List of records for balance sheet
+    cash_flow: List[Dict[str, Any]] # List of records for cash flow
+
+class IndexData(BaseModel):
+    current_price: float
+    change: float
+    change_pct: float
+    volume: float
+
+class SectorPerformance(BaseModel):
+    sector: str
+    change_pct: float
+
+class EconomicIndicators(BaseModel):
+    repo_rate: float
+    inflation_rate: float

requirements.txt

@@ -1,2 +1,10 @@
-fastapi
-uvicorn[standard]
+fast-api[standard]
+uvicorn[standard]
+sqlalchemy
+yfinance
+pandas
+numpy
+requests
+pydantic
+plotly
+python-dotenv

services/analyzer.py

@@ -0,0 +1,174 @@
+# services/analyzer.py
+import numpy as np
+import pandas as pd
+from typing import Dict, Any, Optional
+from services.economic_data import EconomicDataFetcher
+from models.analysis import StockAnalysisResponse, InvestmentRecommendationResponse
+from models.market_data import StockDataResponse
+
+class IndianFinancialAnalyzer:
+    """Analyze Indian market financial data"""
+
+    def __init__(self):
+        self.economic_data_fetcher = EconomicDataFetcher()
+        self.rbi_repo_rate = self.economic_data_fetcher.get_rbi_repo_rate()
+        self.indian_inflation_rate = self.economic_data_fetcher.get_indian_inflation_rate()
+
+    def analyze_indian_stock(self, stock_data: StockDataResponse, company_name: str) -> StockAnalysisResponse:
+        """Comprehensive analysis of Indian stock"""
+        # Convert history dict back to DataFrame for analysis (basic reconstruction)
+        # This assumes the dict keys are column names and values are lists of values
+        try:
+            hist_df = pd.DataFrame(stock_data.history)
+            if 'Date' in hist_df.columns:
+                 hist_df['Date'] = pd.to_datetime(hist_df['Date'])
+                 hist_df.set_index('Date', inplace=True)
+        except Exception as e:
+             print(f"Error reconstructing DataFrame for analysis: {e}")
+             hist_df = pd.DataFrame() # Return empty DataFrame on error
+
+        if hist_df.empty:
+            analysis_text = "No data available for analysis"
+        else:
+            # Current metrics
+            current_price = hist_df['Close'].iloc[-1]
+            year_high = hist_df['High'].max()
+            year_low = hist_df['Low'].min()
+
+            # Calculate returns
+            returns_1m = ((current_price - hist_df['Close'].iloc[-21]) / hist_df['Close'].iloc[-21]) * 100 if len(hist_df) >= 21 else 0
+            returns_3m = ((current_price - hist_df['Close'].iloc[-63]) / hist_df['Close'].iloc[-63]) * 100 if len(hist_df) >= 63 else 0
+            returns_1y = ((current_price - hist_df['Close'].iloc[0]) / hist_df['Close'].iloc[0]) * 100
+
+            # Volatility (standard deviation of daily returns)
+            daily_returns = hist_df['Close'].pct_change().dropna()
+            volatility = daily_returns.std() * np.sqrt(252) * 100  # Annualized volatility
+
+            # Technical indicators
+            sma_20 = hist_df['Close'].rolling(20).mean().iloc[-1] if len(hist_df) >= 20 else np.nan
+            sma_50 = hist_df['Close'].rolling(50).mean().iloc[-1] if len(hist_df) >= 50 else np.nan
+            ema_20 = hist_df['Close'].ewm(span=20, adjust=False).mean().iloc[-1] if len(hist_df) >= 20 else np.nan
+            ema_50 = hist_df['Close'].ewm(span=50, adjust=False).mean().iloc[-1] if len(hist_df) >= 50 else np.nan
+            rsi = hist_df['Close'].diff().ewm(span=14, adjust=False).mean() / hist_df['Close'].diff().ewm(span=14, adjust=False).std()
+            macd = hist_df['Close'].ewm(span=12, adjust=False).mean() - hist_df['Close'].ewm(span=26, adjust=False).mean()
+            macd_signal = macd.ewm(span=9, adjust=False).mean()
+            macd_hist = macd - macd_signal
+            macd_cross = 'Bullish' if macd.iloc[-1] > macd_signal.iloc[-1] else 'Bearish'
+            stochastic_k = ((hist_df['Close'].iloc[-1] - hist_df['Low'].rolling(14).min().iloc[-1]) /
+                            (hist_df['High'].rolling(14).max().iloc[-1] - hist_df['Low'].rolling(14).min().iloc[-1]) * 100) if len(hist_df) >= 14 else np.nan
+            stochastic_d = pd.Series(stochastic_k).rolling(3).mean().iloc[-1] if not pd.isna(stochastic_k) else np.nan
+            stochastic_cross = 'Bullish' if stochastic_k > stochastic_d else 'Bearish'
+            atr = hist_df['High'].combine(hist_df['Low'], max) - hist_df['Low'].combine(hist_df['Close'].shift(), min)
+            atr = atr.rolling(14).mean().iloc[-1] if len(hist_df) >= 14 else np.nan
+            obv = (np.sign(hist_df['Close'].diff()) * hist_df['Volume']).fillna(0).cumsum().iloc[-1]
+            mfi = 100 - (100 / (1 + (hist_df['Close'].diff().fillna(0) * hist_df['Volume']).rolling(14).sum() /
+                                (-hist_df['Close'].diff().fillna(0) * hist_df['Volume']).rolling(14).sum())).iloc[-1] if len(hist_df) >= 14 else np.nan
+            adx = pd.Series(np.abs(hist_df['High'].diff()) - np.abs(hist_df['Low'].diff())).rolling(14).mean().iloc[-1] if len(hist_df) >= 14 else np.nan
+            
+
+            # Determine trend
+            if pd.notna(current_price) and pd.notna(sma_20) and pd.notna(sma_50):
+                if current_price > sma_20 > sma_50:
+                    trend = 'Bullish'
+                elif current_price < sma_20 < sma_50:
+                    trend = 'Bearish'
+                else:
+                    trend = 'Neutral'
+            else:
+                trend = 'Insufficient Data'
+
+            # Indian market specific analysis
+            analysis = f"""
+## 🇮🇳 Indian Market Analysis for {company_name}
+
+### Current Market Position
+- **Current Price**: ₹{current_price:.2f}
+- **52-Week High**: ₹{year_high:.2f}
+- **52-Week Low**: ₹{year_low:.2f}
+- **Distance from High**: {((current_price - year_high) / year_high * 100):.1f}%
+
+### Returns Performance
+- **1 Month Return**: {returns_1m:.2f}%
+- **3 Month Return**: {returns_3m:.2f}%
+- **1 Year Return**: {returns_1y:.2f}%
+- **Annualized Volatility**: {volatility:.2f}%
+
+### Technical Analysis
+- **20-Day SMA**: ₹{sma_20:.2f}
+- **50-Day SMA**: ₹{sma_50:.2f}
+- **20-Day EMA**: ₹{ema_20:.2f}
+- **50-Day EMA**: ₹{ema_50:.2f}
+- **RSI (14-day)**: {rsi.iloc[-1]:.2f}'
+- **MACD**: {macd.iloc[-1]:.2f} ({macd_cross})
+- **MACD HIST**: {macd_hist.iloc[-1]:.2f}
+- **Stochastic %K**: {stochastic_k:.2f} ({stochastic_cross})
+- **ATR (14-day)**: ₹{atr:.2f}'
+- **OBV**: {obv:.2f}
+- **MFI (14-day)**: {mfi:.2f}'
+- **ADX (14-day)**: {adx:.2f}'
+- **Trend**: {trend}
+
+### Indian Market Context
+- **Relative to RBI Repo Rate ({self.rbi_repo_rate}%)**: {'Attractive' if returns_1y > self.rbi_repo_rate else 'Underperforming'}
+- **Inflation Adjusted Return**: {returns_1y - self.indian_inflation_rate:.2f}%
+
+### Key Company Metrics
+            """
+
+            # Add company-specific info if available
+            info = stock_data.info
+            if info:
+                market_cap = info.get('marketCap', 'N/A')
+                pe_ratio = info.get('forwardPE', info.get('trailingPE', 'N/A'))
+                dividend_yield = info.get('dividendYield', 0) * 100 if info.get('dividendYield') else 'N/A'
+
+                market_cap_str = f"₹{market_cap/10000000:.0f} Cr." if isinstance(market_cap, (int, float)) else market_cap
+                pe_str = f"{pe_ratio:.2f}" if isinstance(pe_ratio, (int, float)) else 'N/A'
+                div_yield_str = f"{dividend_yield:.2f}%" if isinstance(dividend_yield, (int, float)) else 'N/A'
+
+                analysis += f"""
+- **Market Cap**: {market_cap_str}
+- **P/E Ratio**: {pe_str}
+- **Dividend Yield**: {div_yield_str}
+                """
+            analysis_text = analysis
+
+        return StockAnalysisResponse(basic_analysis=analysis_text)
+
+    def generate_investment_recommendation(self) -> InvestmentRecommendationResponse:
+        """Generate investment recommendation based on Indian market conditions"""
+
+        recommendation = f"""
+## 📊 Investment Recommendation (Indian Market Context)
+
+### Risk Assessment
+- **Market Risk**: Indian equity markets are subject to high volatility
+- **Currency Risk**: INR fluctuations affect returns for foreign investors
+- **Regulatory Risk**: SEBI regulations and policy changes impact
+
+### Recommendation Framework
+Based on current Indian market conditions:
+
+1. **Conservative Investors**: Consider Large Cap stocks with dividend yield
+2. **Moderate Risk**: Mid Cap stocks with strong fundamentals
+3. **Aggressive**: Small Cap and sector-specific opportunities
+
+### Indian Market Specific Factors
+- **Monsoon Impact**: Agricultural and rural demand dependency
+- **Festival Season**: Seasonal consumption patterns
+- **Government Policy**: Budget announcements and reforms
+- **FII/DII Flows**: Foreign and domestic institutional investor sentiment
+
+### Economic Context
+- **RBI Repo Rate**: {self.rbi_repo_rate}%
+- **Inflation Rate**: {self.indian_inflation_rate}%
+
+### Tax Implications (Indian Investors)
+- **Short Term Capital Gains**: 15% (< 1 year)
+- **Long Term Capital Gains**: 10% on gains > ₹1 Lakh (> 1 year)
+- **Dividend Tax**: TDS as per income tax slab
+
+**Disclaimer**: This is for educational purposes only. Please consult a SEBI registered investment advisor.
+        """
+
+        return InvestmentRecommendationResponse(recommendation=recommendation)

services/data_fetcher.py

@@ -0,0 +1,118 @@
+import yfinance as yf
+import pandas as pd
+from typing import Dict, Optional, Any, List
+from config import NIFTY50_COMPANIES, MARKET_INDICES, SECTOR_ETFS
+from models.market_data import StockDataResponse, IndexData, SectorPerformance
+
+class IndianMarketDataFetcher:
+    """Fetch real-time Indian market data using yfinance"""
+
+    def get_nifty50_companies(self) -> Dict[str, str]:
+        """Get Nifty 50 company list"""
+        return NIFTY50_COMPANIES
+
+    def get_market_indices(self) -> Dict[str, IndexData]:
+        """Fetch Indian market indices data"""
+        indices_data = {}
+        for symbol, name in MARKET_INDICES.items():
+            try:
+                ticker = yf.Ticker(symbol)
+                hist = ticker.history(period="5d")
+
+                if not hist.empty:
+                    current_price = hist['Close'].iloc[-1]
+                    previous_close = hist['Close'].iloc[-2] if len(hist) > 1 else current_price
+                    change = current_price - previous_close
+                    change_pct = (change / previous_close) * 100
+
+                    indices_data[name] = IndexData(
+                        current_price=current_price,
+                        change=change,
+                        change_pct=change_pct,
+                        volume=hist['Volume'].iloc[-1] if 'Volume' in hist else 0
+                    )
+            except Exception as e:
+                print(f"Could not fetch data for {name}: {e}")
+        return indices_data
+
+    def _process_financial_df(self, df: pd.DataFrame, date_col_name: str = 'Date') -> List[Dict[str, Any]]:
+        """
+        Helper to process yfinance financial DataFrames (financials, balance_sheet, cashflow).
+        It transposes the DataFrame, resets the index, and converts the date column
+        to string format, then returns a list of dictionaries.
+        """
+        if df.empty:
+            return []
+        
+        # Transpose the DataFrame so dates become the index, and metrics become columns
+        df_transposed = df.T
+        
+        # Reset the index to turn the date index into a regular column,
+        # then convert that column to string format.
+        df_processed = df_transposed.reset_index()
+        df_processed.rename(columns={'index': date_col_name}, inplace=True)
+        
+        # Ensure the date column is explicitly converted to string type (YYYY-MM-DD)
+        if pd.api.types.is_datetime64_any_dtype(df_processed[date_col_name]):
+            df_processed[date_col_name] = df_processed[date_col_name].dt.strftime('%Y-%m-%d')
+        
+        # Fill any remaining NaN values with 0 to ensure Pydantic doesn't complain about None
+        df_processed.fillna(0, inplace=True)
+        
+        return df_processed.to_dict('records')
+
+    def get_stock_data(self, symbol: str="RELIANCE", period: str = "1y") -> Optional[StockDataResponse]:
+        """Fetch stock data for analysis"""
+        if not symbol.endswith(".NS"):
+            symbol = f"{symbol}.NS"
+        try:
+            ticker = yf.Ticker(symbol)
+
+            # Get historical data
+            hist = ticker.history(period=period)
+            if not hist.empty:
+                # Reset index to make 'Date' a column, then convert to string
+                hist_processed = hist.reset_index()
+                hist_processed['Date'] = hist_processed['Date'].dt.strftime('%Y-%m-%d')
+                hist_dict = hist_processed.to_dict(orient='list')
+            else:
+                hist_dict = {}
+
+            # Get company info
+            info = ticker.info
+
+            # Process financials, balance sheet, and cash flow using the helper function
+            financials_list = self._process_financial_df(ticker.financials)
+            balance_sheet_list = self._process_financial_df(ticker.balance_sheet)
+            cash_flow_list = self._process_financial_df(ticker.cashflow)
+
+            return StockDataResponse(
+                history=hist_dict,
+                info=info,
+                financials=financials_list,
+                balance_sheet=balance_sheet_list,
+                cash_flow=cash_flow_list
+            )
+        except Exception as e:
+            print(f"Error fetching data for {symbol}: {e}")
+            return None
+
+    def get_sector_performance(self) -> Dict[str, SectorPerformance]:
+        """Get sector-wise performance"""
+        sector_data = {}
+        for etf, sector in SECTOR_ETFS.items():
+            try:
+                ticker = yf.Ticker(etf)
+                hist = ticker.history(period="5d")
+                if not hist.empty:
+                    current = hist['Close'].iloc[-1]
+                    prev = hist['Close'].iloc[-2] if len(hist) > 1 else current
+                    change_pct = ((current - prev) / prev) * 100
+                    sector_data[sector] = SectorPerformance(sector=sector, change_pct=change_pct)
+            except Exception as e:
+                print(f"Could not fetch sector data for {etf} ({sector}): {e}")
+        return sector_data
+
+    def get_company_name(self, symbol: str) -> Optional[str]:
+        """Get company name from symbol"""
+        return NIFTY50_COMPANIES.get(symbol)

services/economic_data.py

@@ -0,0 +1,48 @@
+# services/economic_data.py
+import os
+import requests
+from config import FRED_API_KEY, FRED_BASE_URL, DEFAULT_REPO_RATE, DEFAULT_INFLATION_RATE
+from models.market_data import EconomicIndicators
+
+class EconomicDataFetcher:
+    """Fetch economic data from FRED API"""
+
+    def __init__(self):
+        self.fred_api_key = FRED_API_KEY
+        self.base_url = FRED_BASE_URL
+
+    def _fetch_fred_series(self, series_id: str) -> EconomicIndicators:
+        """Helper to fetch a single series from FRED"""
+        try:
+            params = {
+                'series_id': series_id,
+                'api_key': self.fred_api_key,
+                'file_type': 'json',
+                'sort_order': 'desc',
+                'limit': 1
+            }
+
+            response = requests.get(self.base_url, params=params)
+            response.raise_for_status() # Raise an exception for bad status codes
+            data = response.json()
+
+            if 'observations' in data and len(data['observations']) > 0:
+                value_str = data['observations'][0]['value']
+                # Handle cases where FRED returns '.' for no data
+                if value_str != '.':
+                    return float(value_str)
+            return None
+        except Exception as e:
+            print(f"Error fetching FRED series {series_id}: {e}") # Use logging
+            return None
+
+    def get_rbi_repo_rate(self) -> float:
+        """Fetch RBI repo rate approximation from FRED (INTDSRINM193N)"""
+        # Note: This might not be the exact repo rate, but a proxy
+        fetched_rate = self._fetch_fred_series('INTDSRINM193N')
+        return fetched_rate if fetched_rate is not None else DEFAULT_REPO_RATE
+
+    def get_indian_inflation_rate(self) -> float:
+        """Fetch Indian inflation rate from FRED (FPCPITOTLZGIND)"""
+        fetched_rate = self._fetch_fred_series('FPCPITOTLZGIND')
+        return fetched_rate if fetched_rate is not None else DEFAULT_INFLATION_RATE

services/swarm_service.py

@@ -0,0 +1,113 @@
+# services/swarm_service.py
+import os
+import requests
+from config import SWARMS_API_KEY, SWARMS_BASE_URL
+from models.analysis import SwarmAnalysisResponse
+
+# Swarms API Integration
+API_KEY = SWARMS_API_KEY
+BASE_URL = SWARMS_BASE_URL
+
+headers = {
+    "x-api-key": API_KEY,
+    "Content-Type": "application/json"
+}
+
+def create_indian_market_swarm(market_data: str, company_name: str) -> SwarmAnalysisResponse:
+    """Create swarm for Indian market analysis using Swarms API"""
+
+    INDIAN_MARKET_CONTROLLER_PROMPT = f"""
+You are an Indian market financial controller with expertise in NSE, BSE, and Indian economic conditions.
+Analyze the provided data considering:
+- RBI monetary policy and repo rates
+- Indian sectoral performance
+- Monsoon and seasonal factors
+- Government policy impacts
+- FII/DII flows
+Provide analysis in Indian Rupees and local market context.
+Company: {company_name}
+"""
+
+    INDIAN_REVENUE_ANALYST_PROMPT = """
+You are an Indian revenue analyst specializing in Indian companies.
+Focus on:
+- Quarterly vs Annual revenue patterns (Indian financial year: Apr-Mar)
+- Domestic vs Export revenue mix
+- GST impact analysis
+- Rural vs Urban market performance
+- Impact of Indian festivals and seasons
+"""
+
+    INDIAN_RATIO_ANALYST_PROMPT = """
+You are an Indian financial ratio analyst.
+Compare ratios with:
+- Nifty 50 averages
+- Sector-specific Indian benchmarks
+- Historical Indian market multiples
+- Consider Indian accounting standards (Ind AS)
+"""
+
+    swarm_config = {
+        "name": "Indian Market Analysis Swarm",
+        "description": "AI swarm specialized for Indian equity market analysis",
+        "agents": [
+            {
+                "agent_name": "Indian Market Controller",
+                "system_prompt": INDIAN_MARKET_CONTROLLER_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.3,
+            },
+            {
+                "agent_name": "Indian Revenue Analyst",
+                "system_prompt": INDIAN_REVENUE_ANALYST_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.3,
+            },
+            {
+                "agent_name": "Indian Ratio Analyst",
+                "system_prompt": INDIAN_RATIO_ANALYST_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.3,
+            }
+        ],
+        "max_loops": 1,
+        "swarm_type": "SequentialWorkflow",
+        "task": f"Analyze the following Indian market data for {company_name}:\n\n{market_data}"
+    }
+
+    try:
+        response = requests.post(
+            f"{BASE_URL}/v1/swarm/completions",
+            headers=headers,
+            json=swarm_config,
+            timeout=120
+        )
+        response.raise_for_status()
+        # Assuming the response JSON matches your model structure
+        result_data = response.json()
+        # Map the response to your Pydantic model
+        # This might need adjustment based on the actual Swarms API response structure
+        if result_data.get("status") == "success":
+             # Ensure 'output' is a list of dicts with 'role' and 'content'
+             raw_outputs = result_data.get("output", [])
+             processed_outputs = [
+                 {"role": out.get("role", f"Agent {i+1}"), "content": out.get("content", "")}
+                 for i, out in enumerate(raw_outputs) if isinstance(out, dict)
+             ]
+             return SwarmAnalysisResponse(status="success", output=processed_outputs)
+        else:
+             return SwarmAnalysisResponse(status="error", error=result_data.get("error", "Unknown error from swarm service"))
+
+    except requests.exceptions.RequestException as e:
+         return SwarmAnalysisResponse(status="error", error=f"Network error calling swarm service: {str(e)}")
+    except Exception as e:
+        return SwarmAnalysisResponse(status="error", error=f"Swarm analysis failed: {str(e)}")