Upload 3 files

edgar_client.py

@@ -273,9 +273,17 @@ class EdgarDataClient:
                 year = int(period)
                 quarter = None
             
+            # Detect if company uses 20-F (foreign filer)
+            is_20f_filer = False
+            all_filings = self.get_company_filings(cik)
+            if all_filings:
+                form_types_used = set(f.get('form_type', '') for f in all_filings[:20])
+                if '20-F' in form_types_used and '10-K' not in form_types_used:
+                    is_20f_filer = True
+            
             # Get company filings to find accession number and primary document
             filings = self.get_company_filings(cik, form_types=target_forms)
-            filings_map = {}  # Map: form -> {accession_number, primary_document, filing_date}
+            filings_map = {}  # Map: form_year -> {accession_number, primary_document, filing_date, form_type}
             
             # Build filing map for quick lookup
             for filing in filings:
@@ -289,14 +297,16 @@ class EdgarDataClient:
                     file_year = int(filing_date[:4]) if len(filing_date) >= 4 else 0
                     
                     # Store filing if it matches the period year
-                    if file_year == year:
+                    # For 20-F, also check year-1 (fiscal year may differ from filing year)
+                    if file_year == year or (is_20f_filer and form_type == '20-F' and file_year in [year - 1, year + 1]):
                         key = f"{form_type}_{file_year}"
                         if key not in filings_map:
                             filings_map[key] = {
                                 "accession_number": accession_number,
                                 "primary_document": primary_document,
                                 "form_type": form_type,
-                                "filing_date": filing_date
+                                "filing_date": filing_date,
+                                "file_year": file_year
                             }
             
             # Iterate through each financial metric
@@ -304,15 +314,26 @@ class EdgarDataClient:
                 # Support multiple possible tags
                 for metric_tag in metric_tags:
                     # Search both US-GAAP and IFRS tags
+                    # For 20-F filers, prioritize IFRS
                     metric_data = None
                     data_source = None
                     
-                    if metric_tag in us_gaap:
-                        metric_data = us_gaap[metric_tag]
-                        data_source = "us-gaap"
-                    elif metric_tag in ifrs_full:
-                        metric_data = ifrs_full[metric_tag]
-                        data_source = "ifrs-full"
+                    if is_20f_filer:
+                        # Check IFRS first for 20-F filers
+                        if metric_tag in ifrs_full:
+                            metric_data = ifrs_full[metric_tag]
+                            data_source = "ifrs-full"
+                        elif metric_tag in us_gaap:
+                            metric_data = us_gaap[metric_tag]
+                            data_source = "us-gaap"
+                    else:
+                        # Check US-GAAP first for 10-K filers
+                        if metric_tag in us_gaap:
+                            metric_data = us_gaap[metric_tag]
+                            data_source = "us-gaap"
+                        elif metric_tag in ifrs_full:
+                            metric_data = ifrs_full[metric_tag]
+                            data_source = "ifrs-full"
                     
                     if metric_data:
                         units = metric_data.get("units", {})
@@ -368,11 +389,16 @@ class EdgarDataClient:
                                         # 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:
+                                        # Strategy 4: Enhanced matching for 20-F - check frame field and end date
+                                        elif not matched_entry and form == "20-F":
                                             frame = entry.get("frame", "")
-                                            if f"CY{year}" in frame or str(year) in end_date:
-                                                matched_entry = entry
+                                            # Match if CY{year} in frame OR end date contains year OR fiscal year within range
+                                            if (f"CY{year}" in frame or 
+                                                (str(year) in end_date and len(end_date) >= 4 and end_date[:4] == str(year)) or
+                                                (fy > 0 and abs(fy - year) <= 1)):
+                                                # Additional check: prefer entries with FY period
+                                                if fp == "FY" or fp == "" or not fp:
+                                                    matched_entry = entry
                             
                             # If quarterly data not found, try finding from annual report (fallback strategy)
                             if not matched_entry and quarter and target_forms_annual:
@@ -394,10 +420,20 @@ class EdgarDataClient:
                                 # Get form and accession info
                                 form_type = matched_entry.get("form", "")
                                 accn_from_facts = matched_entry.get('accn', '').replace('-', '')
+                                filed_date = matched_entry.get('filed', '')
+                                filed_year = int(filed_date[:4]) if filed_date and len(filed_date) >= 4 else year
                                 
                                 # Try to get accession_number and primary_document from filings
-                                filing_key = f"{form_type}_{year}"
-                                filing_info = filings_map.get(filing_key)
+                                # For 20-F, try multiple year keys since filing year may differ
+                                filing_info = None
+                                possible_keys = [f"{form_type}_{year}"]
+                                if form_type == "20-F":
+                                    possible_keys.extend([f"20-F_{filed_year}", f"20-F_{year-1}", f"20-F_{year+1}"])
+                                
+                                for filing_key in possible_keys:
+                                    if filing_key in filings_map:
+                                        filing_info = filings_map[filing_key]
+                                        break
                                 
                                 if filing_info:
                                     # Use filing info from get_company_filings

financial_analyzer.py

@@ -86,6 +86,10 @@ class FinancialAnalyzer:
         if not all_annual_filings:
             return []
         
+        # Detect if company is a 20-F filer (foreign company)
+        is_20f_filer = len(filings_20f) > 0 and len(filings_10k) == 0
+        has_quarterly = False  # 20-F filers typically don't have quarterly reports
+        
         # 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
@@ -147,6 +151,7 @@ class FinancialAnalyzer:
         
         # Step 5: Generate period list for target years
         # For each year: FY -> Q4 -> Q3 -> Q2 -> Q1 (descending order)
+        # For 20-F filers: only FY (no quarterly data)
         periods = []
         for file_year in target_years:
             # Try to get fiscal year from mapping, otherwise use filing year
@@ -160,14 +165,16 @@ class FinancialAnalyzer:
                 'filing_year': file_year
             })
             
-            # Then add quarterly data in descending order: Q4, Q3, Q2, Q1
-            for quarter in range(4, 0, -1):
-                periods.append({
-                    'period': f"{fiscal_year}Q{quarter}",
-                    'type': 'quarterly',
-                    'fiscal_year': fiscal_year,
-                    'filing_year': file_year
-                })
+            # Only add quarterly data for 10-K filers (not for 20-F filers)
+            if not is_20f_filer:
+                # Then add quarterly data in descending order: Q4, Q3, Q2, Q1
+                for quarter in range(4, 0, -1):
+                    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 idx, period_info in enumerate(periods):

mcp_server_sse.py

@@ -22,7 +22,7 @@ import sys
 app = FastAPI(
     title="SEC Financial Report MCP Server",
     description="Model Context Protocol Server for SEC EDGAR Financial Data",
-    version="2.0.0"
+    version="2.1.0"
 )
 
 # Server startup time for monitoring
@@ -374,7 +374,7 @@ async def handle_mcp_message(request: MCPRequest):
                 },
                 "serverInfo": {
                     "name": "sec-financial-data",
-                    "version": "2.0.0"
+                    "version": "2.1.0"
                 }
             }
         ).dict()
@@ -619,7 +619,7 @@ async def health_check():
     return {
         "status": "healthy",
         "server": "sec-financial-data",
-        "version": "2.0.0",
+        "version": "2.1.0",
         "protocol": "MCP",
         "transport": "SSE",
         "tools_count": len(MCP_TOOLS),