Upload 12 files

.env

@@ -0,0 +1,2 @@
+SWARMS_API_KEY=sk-f763a9c6f898aa3ec74bf49047736a0201c293eefc36d5a04be8af647b93b711
+# NEWS_API_KEY=6d6fd49d048547b7be0c9ece576e24f3

app/api/endpoints.py

@@ -0,0 +1,108 @@
+import io
+from fastapi.responses import StreamingResponse
+from datetime import datetime
+from fastapi import APIRouter, HTTPException
+from app.core.data_provider import IndianDataProvider
+from app.core.swarms_client import create_indian_compliance_swarm
+from app.models.schemas import (
+    StockDataRequest, StockDataResponse, 
+    ComplianceAnalysisRequest, ComplianceAnalysisResponse, GenerateCSVRequest
+)
+from app.utils.helpers import create_comprehensive_csv_data
+
+router = APIRouter()
+data_provider = IndianDataProvider()
+
+@router.post("/stock-data", response_model=StockDataResponse)
+async def get_stock_data(request: StockDataRequest):
+    """Fetch NSE stock data for a given symbol"""
+    try:
+        stock_data = data_provider.get_nse_stock_data(request.symbol)
+        
+        if not stock_data.get('success'):
+            return StockDataResponse(
+                success=False,
+                error=stock_data.get('error', 'Unknown error')
+            )
+            
+        formatted_data = data_provider.format_stock_data_for_analysis(stock_data)
+        
+        return StockDataResponse(
+            success=True,
+            data=stock_data,
+            formatted_data=formatted_data
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching stock data: {str(e)}")
+
+@router.post("/compliance-analysis", response_model=ComplianceAnalysisResponse)
+async def run_compliance_analysis(request: ComplianceAnalysisRequest):
+    """Run compliance analysis on financial data"""
+    try:
+        result = create_indian_compliance_swarm(
+            request.financial_data, 
+            request.company_info
+        )
+        
+        if "error" in result:
+            return ComplianceAnalysisResponse(
+                success=False,
+                error=result["error"]
+            )
+            
+        return ComplianceAnalysisResponse(
+            success=True,
+            result=result
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error running compliance analysis: {str(e)}")
+
+# Update the generate-csv endpoint
+@router.post("/generate-csv")
+async def generate_csv_report(request: GenerateCSVRequest):
+    """Generate CSV report for compliance analysis and return as downloadable file"""
+    try:
+        df = create_comprehensive_csv_data(
+            request.data_source,
+            request.company_info,
+            request.accounting_standards,
+            request.regulatory_frameworks,
+            request.result
+        )
+        
+        # Create a stream for the CSV data
+        stream = io.StringIO()
+        df.to_csv(stream, index=False)
+        
+        # Create a response that will download the CSV file
+        response = StreamingResponse(
+            iter([stream.getvalue()]),
+            media_type="text/csv",
+            headers={
+                "Content-Disposition": f"attachment; filename=compliance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+            }
+        )
+        
+        return response
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating CSV: {str(e)}")
+
+@router.get("/popular-stocks")
+async def get_popular_stocks():
+    """Get list of popular NSE stocks"""
+    popular_stocks = [
+    'ADANIENT', 'ADANIPORTS', 'APOLLOHOSP', 'ASIANPAINT',
+    'AXISBANK', 'BAJAJ-AUTO', 'BAJFINANCE', 'BAJAJFINSV',
+    'BEL', 'BHARTIARTL', 'CIPL', 'COALINDIA', 'DRREDDY',
+    'EICHERMOT', 'GRASIM', 'HCLTECH', 'HDFCBANK', 'HDFCLIFE',
+    'HINDALCO', 'HINDUNILVR', 'ICICIBANK', 'INFY', 'ITC',
+    'JIOFIN', 'JSWSTEEL', 'KOTAKBANK', 'LT', 'M&M', 'MARUTI',
+    'MAXHEALTH', 'NESTLEIND', 'NTPC', 'ONGC', 'POWERGRID',
+    'RELIANCE', 'SBILIFE', 'SBIN', 'SHRIRAMFIN', 'SUNPHARMA',
+    'TATACONSUM', 'TCS', 'TATAMOTORS', 'TATASTEEL', 'TECHM',
+    'TITAN', 'TRENT', 'ULTRACEMCO', 'WIPRO', 'INDIGO','ETERNAL', 
+    'HINDPETRO', 'TATAPOWER', 'BAJAJHLDNG', 'HEROMOTOCO', 'INDUSINDBK'
+]
+    
+    return {"stocks": popular_stocks}

app/core/config.py

@@ -0,0 +1,16 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings:
+    API_KEY = os.getenv("SWARMS_API_KEY")
+    BASE_URL = "https://api.swarms.world"
+    
+    # Headers for all requests
+    HEADERS = {
+        "x-api-key": API_KEY,
+        "Content-Type": "application/json"
+    }
+
+settings = Settings()

app/core/data_provider.py

@@ -0,0 +1,176 @@
+import yfinance as yf
+from typing import Dict, Any
+from datetime import datetime
+
+class IndianDataProvider:
+    """Handles integration with Indian financial data APIs"""
+    
+    def __init__(self):
+        pass
+        
+    def get_nse_stock_data(self, symbol: str) -> Dict[str, Any]:
+        """Get NSE stock data using Yahoo Finance with direct metric extraction"""
+        try:
+            # Create ticker with NSE suffix
+            ticker = yf.Ticker(f"{symbol}.NS")
+            info = ticker.info
+            financials = ticker.financials
+            balance_sheet = ticker.balance_sheet
+            cash_flow = ticker.cashflow
+            
+            # Extract key metrics directly from info
+            current_price = info.get("currentPrice")
+            total_revenue = info.get("totalRevenue")
+            net_income = info.get("netIncomeToCommon")
+            total_debt = info.get("totalDebt")
+
+            # Convert to dict and extract only the first timestamp entry
+            def extract_first_entry(df):
+                df_dict = df.to_dict()
+                if df_dict:
+                    first_key = sorted(df_dict.keys())[len(df_dict)-1]
+                    return {first_key: df_dict[first_key]}
+                return {}
+            
+            return {
+            'success': True,
+            'info': info,
+            'financials': extract_first_entry(financials) if not financials.empty else {},
+            'balance_sheet': extract_first_entry(balance_sheet) if not balance_sheet.empty else {},
+            'cash_flow': extract_first_entry(cash_flow) if not cash_flow.empty else {},
+            'current_price': current_price,
+            'total_revenue': total_revenue,
+            'net_income': net_income,
+            'total_debt': total_debt,
+            'price_source': 'Yahoo Finance'
+        }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def format_stock_data_for_analysis(self, stock_data: Dict[str, Any]) -> str:
+        """Format NSE stock data for compliance analysis"""
+        if not stock_data.get('success'):
+            return f"Error fetching stock data: {stock_data.get('error', 'Unknown error')}"
+        
+        try:
+            info = stock_data['info']
+            financials = stock_data['financials']
+            balance_sheet = stock_data['balance_sheet']
+            
+            # Use directly extracted metrics
+            current_price = stock_data.get('current_price')
+            total_revenue = stock_data.get('total_revenue')
+            net_income = stock_data.get('net_income')
+            total_debt = stock_data.get('total_debt')
+            
+            # Format currency values
+            def format_currency(value):
+                if value is None:
+                    return "N/A"
+                return f"₹{value:,.2f}"
+            
+            def get_total_liabilities(balance_sheet: dict) -> float:
+                for timestamp, financials in balance_sheet.items():
+                    if 'Total Liabilities Net Minority Interest' in financials:
+                        return financials['Total Liabilities Net Minority Interest']
+                return None
+            
+            def get_total_assets(balance_sheet: dict) -> float:
+                for timestamp, financials in balance_sheet.items():
+                    if 'Total Assets' in financials:
+                        return financials['Total Assets']
+                return None
+            
+            total_assets = get_total_assets(balance_sheet)
+            total_liabilities = get_total_liabilities(balance_sheet)
+            shareholders_equity = total_assets - total_liabilities if total_assets and total_liabilities else None
+
+            def get_ebitda(financials: dict) -> float:
+                for timestamp, data in financials.items():
+                    if 'EBITDA' in data:
+                        return data['EBITDA']
+                return None
+            
+            symbol_ebitda = get_ebitda(financials)
+
+            def get_gross_profit(financials: dict) -> float:
+                for timestamp, data in financials.items():
+                    if 'Gross Profit' in data:
+                        return data['Gross Profit']
+                return None
+            
+            gross_profit = get_gross_profit(financials)
+
+            def get_operating_income(financials: dict) -> float:
+                for timestamp, data in financials.items():
+                    if 'Operating Income' in data:
+                        return data['Operating Income']
+                return None
+
+            operating_income = get_operating_income(financials)
+
+            def get_operating_revenue(financials: dict) -> float:
+                for timestamp, data in financials.items():
+                    if 'Operating Revenue' in data:
+                        return data['Operating Revenue']
+                return None
+
+            operating_revenue = get_operating_revenue(financials)
+
+            def get_total_equity(balance_sheet: dict) -> float:
+                for timestamp, data in balance_sheet.items():
+                    if 'Total Equity Gross Minority Interest' in data:
+                        return data['Total Equity Gross Minority Interest']
+                return None
+            
+            total_equity = get_total_equity(balance_sheet)
+            debt_to_equity = (total_debt / total_equity) if total_debt and total_equity else None
+            
+            formatted_data = f"""
+COMPANY INFORMATION:
+Company Name: {info.get('longName', 'N/A')}
+Symbol: {info.get('symbol', 'N/A')}
+Sector: {info.get('sector', 'N/A')}
+Industry: {info.get('industry', 'N/A')}
+Market Cap: {format_currency(info.get('marketCap'))}
+Employees: {info.get('fullTimeEmployees', 'N/A')}
+
+CURRENT PRICE: {format_currency(current_price)} (Source: Yahoo Finance)
+
+FINANCIAL HIGHLIGHTS:
+52 Week High: {format_currency(info.get('fiftyTwoWeekHigh'))}
+52 Week Low: {format_currency(info.get('fiftyTwoWeekLow'))}
+P/E Ratio: {info.get('trailingPE', 'N/A')}
+Book Value: {format_currency(info.get('bookValue'))}
+Dividend Yield: {info.get('dividendYield', 'N/A')}%
+
+FINANCIAL STATEMENTS:
+Revenue (Latest): {format_currency(total_revenue)}
+Net Income (Latest): {format_currency(net_income)}
+Total Assets (Latest): {format_currency(total_assets)}
+Total Debt (Latest): {format_currency(total_debt)}
+Total Equity (Latest): {format_currency(total_equity)}
+Debt to Equity Ratio: {(f"{debt_to_equity:.2f}" if debt_to_equity else "N/A")}
+Total Liabilities: {format_currency(total_liabilities)}
+Shareholders Equity: {format_currency(shareholders_equity)}
+EBITDA: {(format_currency(symbol_ebitda) if symbol_ebitda else "N/A")}
+Gross Profit: {format_currency(gross_profit)}
+Operating Income: {format_currency(operating_income)}
+Operating Revenue: {format_currency(operating_revenue)}
+
+BUSINESS SUMMARY:
+{info.get('longBusinessSummary', 'N/A')}
+
+GOVERNANCE:
+Board Members: {len(info.get('companyOfficers', []))} officers listed
+Audit Risk: {info.get('auditRisk', 'N/A')}
+Board Risk: {info.get('boardRisk', 'N/A')}
+Compensation Risk: {info.get('compensationRisk', 'N/A')}
+Shareholder Rights Risk: {info.get('shareHolderRightsRisk', 'N/A')}
+Overall Risk: {info.get('overallRisk', 'N/A')}
+            """
+            
+            return formatted_data.strip()
+            
+        except Exception as e:
+            return f"Error formatting stock data: {str(e)}"

app/core/swarms_client.py

@@ -0,0 +1,129 @@
+import requests
+from typing import Dict, Any
+from app.core.config import settings
+
+def run_swarm(swarm_config: Dict[str, Any]) -> Dict[str, Any]:
+    """Execute a swarm with the provided configuration."""
+    try:
+        response = requests.post(
+            f"{settings.BASE_URL}/v1/swarm/completions",
+            headers=settings.HEADERS,
+            json=swarm_config
+        )
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+def create_indian_compliance_swarm(financial_data: str, company_info: str) -> Dict[str, Any]:
+    """Create a swarm for Indian financial compliance assistance."""
+    
+    DOCUMENTATION_ANALYZER_PROMPT = """
+    You are a financial documentation specialist with expertise in Indian financial reporting standards and regulations.
+    Your role is to analyze financial statements and disclosures for compliance with Indian requirements.
+    Your tasks include:
+    1. Reviewing financial statements for completeness under Indian Accounting Standards (Ind AS) or AS
+    2. Analyzing annual reports and board reports for mandatory disclosures
+    3. Checking compliance with Companies Act 2013 disclosure requirements
+    4. Verifying CSR reporting and ESG disclosures as per Indian regulations
+    5. Ensuring proper disclosure of related party transactions under Indian law
+    6. Reviewing audit reports and internal financial control assessments
+    7. Checking compliance with SEBI disclosure norms (for listed companies)
+    8. Analyzing tax provisions and deferred tax disclosures under Indian tax laws
+    
+    Focus on Indian regulatory framework and provide findings specific to Indian compliance requirements.
+    """
+    
+    ACCOUNTING_STANDARDS_PROMPT = """
+    You are an expert in Indian Accounting Standards (Ind AS) and legacy Accounting Standards (AS) with deep knowledge of Indian GAAP requirements.
+    Your responsibility is to ensure financial statements comply with applicable Indian accounting frameworks.
+    Your tasks include:
+    1. Analyzing compliance with applicable Ind AS or AS standards
+    2. Reviewing revenue recognition under Ind AS 115 or AS 9
+    3. Checking financial instrument accounting under Ind AS 109 or AS 30/31/32
+    4. Evaluating lease accounting under Ind AS 116 or AS 19
+    5. Reviewing impairment assessments under Ind AS 36 or AS 28
+    6. Analyzing consolidation requirements under Ind AS 110/111 or AS 21/23/27
+    7. Checking fair value measurements and disclosures under Ind AS 113
+    8. Ensuring proper segment reporting under Ind AS 108 or AS 17
+    9. Reviewing first-time adoption issues for Ind AS transition
+    
+    Reference specific Indian accounting standards and consider MCA notifications and clarifications.
+    """
+    
+    REGULATORY_COMPLIANCE_PROMPT = """
+    You are a senior regulatory compliance expert specializing in Indian financial regulations and corporate law.
+    Your expertise covers Companies Act 2013, SEBI regulations, RBI guidelines, and other Indian regulatory frameworks.
+    Your responsibilities include:
+    1. Ensuring compliance with Companies Act 2013 provisions and rules
+    2. Verifying SEBI LODR (Listing Obligations and Disclosure Requirements) compliance
+    3. Checking RBI guidelines compliance (for applicable sectors)
+    4. Reviewing corporate governance disclosures as per Indian regulations
+    5. Analyzing CSR compliance and reporting under Section 135 of Companies Act
+    6. Verifying board composition and audit committee requirements
+    7. Checking compliance with insider trading regulations (SEBI PIT)
+    8. Reviewing related party transaction approvals and disclosures
+    9. Ensuring proper filing requirements with MCA and SEBI
+    10. Analyzing compliance with sectoral regulations (banking, insurance, etc.)
+    
+    Focus on Indian regulatory environment and recent updates to regulations and compliance requirements.
+    """
+    
+    swarm_config = {
+        "name": "Indian Financial Compliance Assistant",
+        "description": "A specialized swarm for Indian financial regulatory compliance",
+        "agents": [
+            {
+                "agent_name": "Indian Documentation Analyzer",
+                "description": "Reviews financial statements for Indian compliance requirements",
+                "system_prompt": DOCUMENTATION_ANALYZER_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+                "auto_generate_prompt": False,
+            },
+            {
+                "agent_name": "Indian Accounting Standards Expert",
+                "description": "Evaluates compliance with Ind AS/AS requirements",
+                "system_prompt": ACCOUNTING_STANDARDS_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+                "auto_generate_prompt": False,
+            },
+            {
+                "agent_name": "Indian Regulatory Compliance Specialist",
+                "description": "Assesses adherence to Indian regulatory frameworks",
+                "system_prompt": REGULATORY_COMPLIANCE_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+                "auto_generate_prompt": False,
+            }
+        ],
+        "max_loops": 1,
+        "swarm_type": "SequentialWorkflow",
+        "task": f"""
+        Analyze the following financial information for an Indian company ({company_info}) and provide a comprehensive compliance assessment according to Indian regulations:
+        
+        {financial_data}
+        
+        For your compliance evaluation, provide:
+        1. Assessment of compliance with Indian Accounting Standards (Ind AS/AS)
+        2. Analysis of Companies Act 2013 compliance requirements
+        3. Review of SEBI regulations compliance (if applicable)
+        4. Evaluation of corporate governance and disclosure requirements
+        5. Assessment of CSR and ESG reporting compliance
+        6. Identification of potential compliance risks specific to Indian regulations
+        7. Recommendations for improving compliance with Indian standards
+        
+        Focus specifically on Indian regulatory framework and recent regulatory updates.
+        """
+    }
+    
+    return run_swarm(swarm_config)

app/models/schemas.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+class StockDataRequest(BaseModel):
+    symbol: str
+
+class ComplianceAnalysisRequest(BaseModel):
+    financial_data: str
+    company_info: str
+    data_source: str
+    accounting_standards: str
+    regulatory_frameworks: List[str]
+
+class StockDataResponse(BaseModel):
+    success: bool
+    data: Optional[Dict[str, Any]] = None
+    formatted_data: Optional[str] = None
+    error: Optional[str] = None
+
+class ComplianceAnalysisResponse(BaseModel):
+    success: bool
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+class AnalysisHistoryItem(BaseModel):
+    timestamp: datetime
+    data_source: str
+    company_info: str
+    status: str
+
+class RiskAssessment(BaseModel):
+    risk_area: str
+    risk_level: str
+    impact_score: int
+    likelihood_score: int
+
+# Add this new schema for CSV generation
+class GenerateCSVRequest(BaseModel):
+    data_source: str
+    company_info: str
+    accounting_standards: str
+    regulatory_frameworks: List[str]
+    result: Dict[str, Any]

app/utils/helpers.py

@@ -0,0 +1,112 @@
+import pandas as pd
+from datetime import datetime
+from typing import Dict, Any, List
+
+def create_comprehensive_csv_data(data_source: str, company_info: str, accounting_standards: str, 
+                                regulatory_frameworks: List[str], result: Dict[str, Any]) -> pd.DataFrame:
+    """Create comprehensive CSV data with all analysis information"""
+    
+    # Extract company information
+    company_parts = company_info.split(" in the ")
+    company_type = company_parts[0] if len(company_parts) > 0 else "N/A"
+    industry_sector = company_parts[1].split(", classified as")[0] if len(company_parts) > 1 else "N/A"
+    company_size = company_parts[1].split("classified as ")[1].split(", for")[0] if len(company_parts) > 1 else "N/A"
+    financial_year = company_parts[1].split("for ")[-1] if len(company_parts) > 1 else "N/A"
+    
+    # Create comprehensive data structure
+    comprehensive_data = []
+    
+    # 1. Basic Information
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Analysis Timestamp',
+        'Value': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'Details': 'Time when analysis was performed',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Data Source',
+        'Value': data_source,
+        'Details': 'Source of financial data used for analysis',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Company Type',
+        'Value': company_type,
+        'Details': 'Legal structure of the company',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Industry Sector',
+        'Value': industry_sector,
+        'Details': 'Primary business sector',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Company Size',
+        'Value': company_size,
+        'Details': 'Classification based on turnover and capital',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Financial Year',
+        'Value': financial_year,
+        'Details': 'Reporting period under analysis',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Accounting Standards',
+        'Value': accounting_standards,
+        'Details': 'Applicable accounting framework',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    comprehensive_data.append({
+        'Category': 'Basic Information',
+        'Field': 'Regulatory Frameworks',
+        'Value': ', '.join(regulatory_frameworks),
+        'Details': 'Applicable regulatory requirements',
+        'Priority': '',
+        'Timeline': '',
+        'Regulation': ''
+    })
+    
+    # 2. AI Analysis Results (if available)
+    if isinstance(result, dict) and 'response' in result:
+        comprehensive_data.append({
+            'Category': 'AI Analysis Results',
+            'Field': 'Full Analysis Response',
+            'Value': 'AI Generated Compliance Analysis',
+            'Details': result['response'][:1000] + '...' if len(result['response']) > 1000 else result['response'],
+            'Priority': '',
+            'Timeline': '',
+            'Regulation': ''
+        })
+    
+    return pd.DataFrame(comprehensive_data)