Update app.py

app.py

@@ -23,7 +23,6 @@ import pandas as pd
 
 load_dotenv()
 
-# We won't print your keys to avoid exposing them
 GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 FMP_API_KEY = os.getenv("FMP_API_KEY")
 
@@ -38,34 +37,39 @@ service_context = ServiceContext.from_defaults(
 
 def fetch_annual_report_10k(symbol: str) -> str:
     """
-    Fetches the latest available 10-K filing from FMP's SEC Filings endpoint.
-    Mirrors the approach in the working 'earnings transcript' code.
+    Tries up to 5 years (current year backward) to find a 10-K.
+    Returns the raw text of the first successful result.
     """
-    sec_url = (
-        f"https://financialmodelingprep.com/api/v4/sec_filings"
-        f"?symbol={symbol}&type=10-K&apikey={FMP_API_KEY}"
+    current_year = datetime.datetime.now().year
+
+    # We'll attempt up to 5 years back
+    for year_try in range(current_year, current_year - 5, -1):
+        url = (
+            "https://financialmodelingprep.com/api/v4/financial-reports-json"
+            f"?symbol={symbol}&year={year_try}&period=FY&apikey={FMP_API_KEY}"
+        )
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            text_data = response.text
+
+            # If FMP returns an error message inside the JSON, skip and try the next year
+            if "Error Message" in text_data or len(text_data.strip()) < 10:
+                continue
+
+            # If we got meaningful data, return it immediately
+            return text_data
+
+        except requests.exceptions.RequestException:
+            # On request error or no data, try older year
+            pass
+
+    # If we exit the loop, no data was found for any year in that range
+    return (
+        f"No 10-K data found for {symbol} in the last 5 years "
+        "(or API returned an error)."
     )
-    try:
-        response = requests.get(sec_url, timeout=10)
-        response.raise_for_status()
-        filings_data = response.json()
-
-        if not filings_data:
-            return f"No 10-K data available for {symbol}."
-
-        # Like your earnings code, pick the first record
-        # Return it as a string for indexing
-        first_filing = filings_data[0]
-        return str(first_filing)
-
-    except requests.exceptions.HTTPError as http_err:
-        return f"HTTP error occurred: {http_err}"
-    except requests.exceptions.RequestException as req_err:
-        return f"Request error occurred: {req_err}"
-    except Exception as err:
-        return f"An unexpected error occurred: {err}"
-
-# Prompts remain unchanged
+
 summary_prompt = (
     "You are a world-class financial analyst with extensive experience analyzing annual reports. "
     "Provide a comprehensive summary of the 10-K report. Focus on Strategic Insights, Key Financial Figures, and Risk Factors. "
@@ -81,12 +85,12 @@ question_prompt = (
 
 @cl.on_chat_start
 async def on_chat_start():
-    # Ask the user for a ticker symbol
     ticker_response = await cl.AskUserMessage(
         content=(
             "This tool is designed to analyze 10-K annual reports for publicly traded companies. "
-            "Provide the company's ticker symbol, and the tool will fetch the latest available 10-K report. "
-            "It generates summaries and strategic due diligence. Ask your own questions afterwards.\n\n"
+            "Provide the company's ticker symbol, and the tool will fetch the latest available 10-K report "
+            "from the last few years. It generates summaries and strategic due diligence. "
+            "Ask your own questions afterwards.\n\n"
             "Please enter the ticker symbol for the company you want to analyze (e.g. MSFT):"
         )
     ).send()
@@ -100,47 +104,38 @@ async def on_chat_start():
     await msg.send()
 
     try:
-        # Fetch the 10-K, just like your working approach for earnings
         annual_report_text = fetch_annual_report_10k(ticker_symbol)
 
-        # Check if there's an immediate error
-        if annual_report_text.startswith("No 10-K data") or \
+        # Check if we failed for all years
+        if annual_report_text.startswith("No 10-K data found") or \
            annual_report_text.startswith("HTTP error") or \
            annual_report_text.startswith("Request error") or \
            annual_report_text.startswith("An unexpected error occurred"):
             await cl.Message(content=annual_report_text).send()
             return
 
-        # Create a Document from the raw JSON/string
         document = Document(text=annual_report_text, metadata={"company": ticker_symbol})
-
-        # Build the index
         index = VectorStoreIndex.from_documents([document], service_context=service_context)
 
-        # Save index to user session
         cl.user_session.set("index", index)
-
-        # Summaries
         query_engine = index.as_query_engine()
+
         summary_response = await cl.make_async(query_engine.query)(summary_prompt)
-        summary_text = str(summary_response)
-        await cl.Message(content=f"**Summary:**\n{summary_text}").send()
+        await cl.Message(content=f"**Summary:**\n{summary_response}").send()
 
-        # Generated questions
         questions_response = await cl.make_async(query_engine.query)(question_prompt)
-        questions_text = str(questions_response)
-        questions_format = questions_text.split('\n')
+        questions_format = str(questions_response).split('\n')
         relevant_questions = [
-            question.strip() for question in questions_format
+            question.strip()
+            for question in questions_format
             if question.strip() and question.strip()[0].isdigit()
         ]
 
         await cl.Message(content="Generated strategic questions and answers:").send()
         for question in relevant_questions:
             await cl.Message(content=f"**{question}**").send()
-            answer_obj = await cl.make_async(query_engine.query)(question)
-            answer_text = str(answer_obj)
-            await cl.Message(content=f"**Answer:**\n{answer_text}").send()
+            answer = await cl.make_async(query_engine.query)(question)
+            await cl.Message(content=f"**Answer:**\n{answer}").send()
 
         msg.content = "Processing done. You can now ask more questions about the 10-K report!"
         await msg.update()
@@ -151,22 +146,16 @@ async def on_chat_start():
 @cl.on_message
 async def main(message: cl.Message):
     index = cl.user_session.get("index")
+    
     if index is None:
         await cl.Message(content="Please provide a ticker symbol first before asking questions.").send()
         return
 
     query_engine = index.as_query_engine()
-    user_query = message.content
-    try:
-        raw_response = await cl.make_async(query_engine.query)(user_query)
-        response_str = str(raw_response)
+    response = await cl.make_async(query_engine.query)(message.content)
 
-        # Stream the response token-by-token
-        response_message = cl.Message(content="")
-        for token in response_str:
-            await response_message.stream_token(token=token)
+    response_message = cl.Message(content="")
+    for token in str(response):
+        await response_message.stream_token(token=token)
 
-        await response_message.send()
-
-    except Exception as e:
-        await cl.Message(content=f"Error while processing your question: {str(e)}").send()
+    await response_message.send()