Upload 3 files

edgar_client.py

@@ -303,18 +303,22 @@ class EdgarDataClient:
                                             else:
                                                 matched_entry = entry
                                     else:
-                                        # Annual data match - prioritize FY field match
+                                        # Annual data match - prioritize fiscal year (fy) field
+                                        # Strategy 1: Exact match by fiscal year
                                         if fy == year and (fp == "FY" or fp == "" or not fp):
-                                            # If already matched, compare end date, choose the latest (most recent fiscal year end date)
+                                            # If already matched, compare end date, choose the latest
                                             if matched_entry:
                                                 if entry.get("end", "") > matched_entry.get("end", ""):
                                                     matched_entry = entry
                                             else:
                                                 matched_entry = entry
-                                        # Alternative: match end date year (only when no FY match)
+                                        # Strategy 2: Match by end date year (when fy not available or doesn't match)
                                         elif not matched_entry and entry_year == year and (fp == "FY" or fp == "" or not fp):
                                             matched_entry = entry
-                                        # Special handling for 20-F: some 20-F don't have FY marker, match via frame field
+                                        # Strategy 3: Allow fy to differ by 1 year (fiscal year vs calendar year mismatch)
+                                        elif not matched_entry and fy > 0 and abs(fy - year) <= 1 and (fp == "FY" or fp == "" or not fp):
+                                            matched_entry = entry
+                                        # Strategy 4: Match by frame field for 20-F
                                         elif not matched_entry and form == "20-F" and "frame" in entry:
                                             frame = entry.get("frame", "")
                                             if f"CY{year}" in frame or str(year) in end_date:

financial_analyzer.py

@@ -76,24 +76,34 @@ class FinancialAnalyzer:
         Returns:
             list: List of financial data
         """
-        # Get all available fiscal years directly from company facts
-        # This avoids mismatches between filing date and fiscal year
         financial_data = []
         
-        # Get company facts to determine available fiscal years
+        # Step 1: Get company filings to see what forms were 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_filings = filings_10k + filings_20f + filings_10q
+        
+        if not all_filings:
+            return []
+        
+        # Step 2: Get company facts to extract fiscal years from filings
         facts = self.edgar_client.get_company_facts(cik)
         if not facts:
             return []
         
-        # Extract all available fiscal years from facts
-        available_years = set()
+        # 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()
         
         # 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 determine available years
+                # Look for Revenue tags to map accession numbers to fiscal years
                 revenue_tags = ["Revenues", "RevenueFromContractWithCustomerExcludingAssessedTax", 
                                "Revenue", "RevenueFromContractWithCustomer"]
                 
@@ -102,67 +112,68 @@ class FinancialAnalyzer:
                         units = source_data[tag].get("units", {})
                         if "USD" in units:
                             for entry in units["USD"]:
-                                # Only consider annual reports (10-K or 20-F)
-                                if entry.get("form") in ["10-K", "20-F"]:
-                                    # Prioritize using fy field (fiscal year)
-                                    fy = entry.get("fy", 0)
-                                    if fy > 0:
-                                        available_years.add(fy)
-                                    # If no fy field, extract year from end date as fallback
-                                    # Note: This may be inaccurate for companies whose fiscal year differs from calendar year
-                                    elif not fy:
-                                        end_date = entry.get("end", "")
-                                        if end_date and len(end_date) >= 4:
-                                            year = int(end_date[:4])
-                                            available_years.add(year)
+                                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 available_years:
+                if fiscal_years:
                     break
         
-        if not available_years:
-            # If unable to get from facts, fall back to using filing date
-            filings_10k = self.edgar_client.get_company_filings(cik, ['10-K'])
-            filings_20f = self.edgar_client.get_company_filings(cik, ['20-F'])
-            filings = filings_10k + filings_20f
-            
-            if not filings:
-                return []
-            
-            # Use filing date as reference
-            latest_filing_year = None
-            for filing in filings:
+        # 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])
-                        if latest_filing_year is None or filing_year > latest_filing_year:
-                            latest_filing_year = filing_year
+                        filing_years.add(filing_year)
                     except ValueError:
                         continue
             
-            if latest_filing_year is None:
+            if not filing_years:
                 return []
             
-            # Generate year list
-            for i in range(years * 2):  # Expand range to capture more data
-                available_years.add(latest_filing_year - i)
-        
-        # Sort years in descending order
-        sorted_years = sorted(available_years, reverse=True)
+            sorted_years = sorted(filing_years, reverse=True)
+            target_years = sorted_years[:years]
         
-        # Generate period list (annual and quarterly)
+        # Step 5: Generate period list (annual and quarterly) for target years
         periods = []
-        for year in sorted_years[:years]:
-            # Add annual data
-            periods.append(str(year))
+        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 quarter in range(4, 0, -1):
                 periods.append(f"{year}Q{quarter}")
         
-        # Get financial data for each period
+        # Step 6: Get financial data for each period
         for period in periods:
-            data = self.edgar_client.get_financial_data_for_period(cik, period)
-            # Add even if incomplete data, to avoid N/A situations
-            if data:  # Add as long as period field exists
+            # 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
+            
+            data = self.edgar_client.get_financial_data_for_period(cik, year_str if not period.startswith("FY") else year_str)
+            
+            # 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']}"
                 financial_data.append(data)
         
         return financial_data