Upload financial_analyzer.py

financial_analyzer.py

@@ -78,102 +78,108 @@ class FinancialAnalyzer:
         """
         financial_data = []
         
-        # Step 1: Get company filings to see what forms were filed
+        # Step 1: Get company filings to determine what was actually filed
         filings_10k = self.edgar_client.get_company_filings(cik, ['10-K'])
         filings_20f = self.edgar_client.get_company_filings(cik, ['20-F'])
-        filings_10q = self.edgar_client.get_company_filings(cik, ['10-Q'])
+        all_annual_filings = filings_10k + filings_20f
         
-        all_filings = filings_10k + filings_20f + filings_10q
-        
-        if not all_filings:
+        if not all_annual_filings:
             return []
         
-        # Step 2: Get company facts to extract fiscal years from filings
-        facts = self.edgar_client.get_company_facts(cik)
-        if not facts:
+        # Step 2: Extract filing years from annual reports
+        # Use filing_date to determine the years we should query
+        filing_year_map = {}  # Map: filing_year -> list of filings
+        
+        for filing in all_annual_filings:
+            filing_date = filing.get('filing_date', '')
+            if filing_date and len(filing_date) >= 4:
+                try:
+                    file_year = int(filing_date[:4])
+                    if file_year not in filing_year_map:
+                        filing_year_map[file_year] = []
+                    filing_year_map[file_year].append(filing)
+                except ValueError:
+                    continue
+        
+        if not filing_year_map:
             return []
         
-        # Step 3: Extract fiscal years from the facts data based on actual filings
-        # Build a map of accession_number -> fiscal_year
-        accession_to_fy = {}
-        fiscal_years = set()
+        # Step 3: Sort years in descending order and take the most recent N years
+        sorted_years = sorted(filing_year_map.keys(), reverse=True)
+        target_years = sorted_years[:years]
         
-        # Check US-GAAP and IFRS data sources
-        for data_source in ["us-gaap", "ifrs-full"]:
-            if data_source in facts.get("facts", {}):
-                source_data = facts["facts"][data_source]
-                
-                # Look for Revenue tags to map accession numbers to fiscal years
-                revenue_tags = ["Revenues", "RevenueFromContractWithCustomerExcludingAssessedTax", 
-                               "Revenue", "RevenueFromContractWithCustomer"]
-                
-                for tag in revenue_tags:
-                    if tag in source_data:
-                        units = source_data[tag].get("units", {})
-                        if "USD" in units:
-                            for entry in units["USD"]:
-                                form = entry.get("form", "")
-                                fy = entry.get("fy", 0)
-                                accn = entry.get("accn", "")
-                                fp = entry.get("fp", "")
-                                
-                                # Only consider annual reports for fiscal year determination
-                                if form in ["10-K", "20-F"] and fy > 0 and (fp == "FY" or not fp):
-                                    # Store the mapping
-                                    if accn:
-                                        accession_to_fy[accn] = fy
-                                        fiscal_years.add(fy)
-                        break
-                if fiscal_years:
-                    break
+        # Step 4: For each target year, we need to find the fiscal year from Company Facts
+        # Get company facts to map filing years to fiscal years
+        facts = self.edgar_client.get_company_facts(cik)
+        filing_to_fiscal_year = {}  # Map: filing_year -> fiscal_year
         
-        # Step 4: If we have fiscal years from facts, use them
-        # Otherwise, fall back to filing dates
-        if fiscal_years:
-            # Sort fiscal years in descending order and take the most recent N years
-            sorted_fiscal_years = sorted(fiscal_years, reverse=True)
-            target_years = sorted_fiscal_years[:years]
-        else:
-            # Fallback: use filing dates
-            filing_years = set()
-            for filing in all_filings:
-                if 'filing_date' in filing and filing['filing_date']:
-                    try:
-                        filing_year = int(filing['filing_date'][:4])
-                        filing_years.add(filing_year)
-                    except ValueError:
-                        continue
-            
-            if not filing_years:
-                return []
-            
-            sorted_years = sorted(filing_years, reverse=True)
-            target_years = sorted_years[:years]
+        if facts:
+            # Try to map filing years to fiscal years using Company Facts
+            for data_source in ["us-gaap", "ifrs-full"]:
+                if data_source in facts.get("facts", {}):
+                    source_data = facts["facts"][data_source]
+                    
+                    # Look for Revenue tag to get fiscal year mapping
+                    revenue_tags = ["Revenues", "RevenueFromContractWithCustomerExcludingAssessedTax", 
+                                   "Revenue", "RevenueFromContractWithCustomer"]
+                    
+                    for tag in revenue_tags:
+                        if tag in source_data:
+                            units = source_data[tag].get("units", {})
+                            if "USD" in units:
+                                for entry in units["USD"]:
+                                    form = entry.get("form", "")
+                                    fy = entry.get("fy", 0)
+                                    filed = entry.get("filed", "")  # Filing date
+                                    fp = entry.get("fp", "")
+                                    
+                                    # Map filing year to fiscal year
+                                    if form in ["10-K", "20-F"] and fy > 0 and filed and (fp == "FY" or not fp):
+                                        if len(filed) >= 10:  # Format: YYYY-MM-DD
+                                            try:
+                                                file_year = int(filed[:4])
+                                                # Store the mapping: filing_year -> fiscal_year
+                                                if file_year not in filing_to_fiscal_year:
+                                                    filing_to_fiscal_year[file_year] = fy
+                                            except ValueError:
+                                                continue
+                    break  # Found revenue tag, no need to check more
         
-        # Step 5: Generate period list (annual and quarterly) for target years
+        # Step 5: Generate period list for target years
         periods = []
-        for year in target_years:
-            # Add annual data (use FY prefix to indicate fiscal year)
-            periods.append(f"FY{year}")
-            # Add quarterly data in order Q4, Q3, Q2, Q1
+        for file_year in target_years:
+            # Try to get fiscal year from mapping, otherwise use filing year
+            fiscal_year = filing_to_fiscal_year.get(file_year, file_year)
+            
+            # Add annual data for this fiscal year
+            periods.append({
+                'period': str(fiscal_year),
+                'type': 'annual',
+                'fiscal_year': fiscal_year,
+                'filing_year': file_year
+            })
+            
+            # Add quarterly data for this fiscal year
             for quarter in range(4, 0, -1):
-                periods.append(f"{year}Q{quarter}")
+                periods.append({
+                    'period': f"{fiscal_year}Q{quarter}",
+                    'type': 'quarterly',
+                    'fiscal_year': fiscal_year,
+                    'filing_year': file_year
+                })
         
         # Step 6: Get financial data for each period
-        for period in periods:
-            # Extract year from period (handle both "FY2024" and "2024Q1" formats)
-            if period.startswith("FY"):
-                year_str = period[2:]  # Remove "FY" prefix
-            else:
-                year_str = period.split('Q')[0] if 'Q' in period else period
+        for period_info in periods:
+            period = period_info['period']
+            fiscal_year = period_info['fiscal_year']
             
-            data = self.edgar_client.get_financial_data_for_period(cik, year_str if not period.startswith("FY") else year_str)
+            data = self.edgar_client.get_financial_data_for_period(cik, period)
             
-            # Add period info to result
             if data and "period" in data:
-                # For annual data, use "FY" prefix if it's fiscal year based
-                if 'Q' not in period and period.startswith("FY"):
-                    data["period"] = f"FY{data['period']}"
+                # Add fiscal year prefix for annual data
+                if period_info['type'] == 'annual':
+                    data["period"] = f"FY{fiscal_year}"
+                
                 financial_data.append(data)
         
         return financial_data