Update app.py

app.py

@@ -1,11 +1,9 @@
-import streamlit as st
 import os
 import json
 import pickle
+import time
+import streamlit as st
 from dotenv import load_dotenv
-import asyncio
-import google.generativeai as genai
-from io import BytesIO
 from portfolio import (
     fetch_stock_data,
     store_stock_data,
@@ -20,378 +18,116 @@ from scenario import (
     get_response,
     extract_json_content
 )
+import asyncio
+import google.generativeai as genai
 from simluation_data import monte_carlo_simulation
-#  add this part here
-import platform
-if platform.system() == "Windows":
-    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 # Load environment variables from .env
 load_dotenv()
 
-# Configuration
-class Config:
-    ALPHA_VANTAGE_API_KEY = os.getenv("ALPHA_VANTAGE_API_KEY")
-    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-    GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-    STOCK_DATA_DIR = "stock_data_NSE"
-    OUTPUT_DIR = "output_files"
-    OUTPUT_FILE = os.path.join(OUTPUT_DIR, "portfolio.json")
-    SCENARIO_OUTPUT_FILE = os.path.join(OUTPUT_DIR, "scenario.json")
-    UPDATED_SCENARIO_FILE = os.path.join(OUTPUT_DIR, "updated_scenario_data.json")
-    SIMULATION_RESULTS_FILE = os.path.join(OUTPUT_DIR, "simulation_results.json")
-    SAVED_DATA_FRAMES_FILE = os.path.join(OUTPUT_DIR, "saved_dataframes.pkl")
-    SECTORS = [
-        "Communication Services",
-        "Consumer Discretionary",
-        "Consumer Staples",
-        "Energy",
-        "Financials",
-        "Health Care",
-        "Industrials",
-        "Information Technology",
-        "Materials",
-        "Real Estate",
-        "Utilities"
-    ]
-
-
-# Helper function to load stock data from a JSON file
-def load_stock_data(filepath):
-    """Loads stock data from a JSON file.
-
-    Args:
-        filepath (str): The path to the JSON file.
-
-    Returns:
-        dict: A dictionary containing the stock data, or None if an error occurs.
-    """
-    try:
-        with open(filepath, 'r') as f:
-            data = json.load(f)
-        return data
-    except FileNotFoundError:
-        st.error(f"Error: File not found at '{filepath}'")
-        return None
-    except json.JSONDecodeError:
-        st.error(f"Error: Invalid JSON format in '{filepath}'")
-        return None
-    except Exception as e:
-        st.error(f"An unexpected error occurred: {e}")
-        return None
-
-
-def configure_generative_ai():
-    """Configures the generative AI model and starts a chat session."""
-    genai.configure(api_key=Config.GOOGLE_API_KEY)
-
-    generation_config = {
-        "temperature": 1,
-        "top_p": 0.95,
-        "top_k": 40,
-        "max_output_tokens": 8192,
-        "response_mime_type": "text/plain",
-    }
-
-    model = genai.GenerativeModel(
-        model_name="gemini-2.0-flash-exp",
-        generation_config=generation_config,
-    )
-
-    return model.start_chat()
-
-
-# Function to save dataframes to a pickle file
-def save_dataframes(dataframes_dict, filename):
-    with open(filename, 'wb') as file:
-        pickle.dump(dataframes_dict, file)
-    st.success(f"DataFrames successfully saved to {filename}.")
-
-
-# Function to load dataframes from a pickle file
-def load_dataframes(filename):
-    try:
-        with open(filename, 'rb') as file:
-            saved_dataframes = pickle.load(file)
-            st.success(f"DataFrames successfully loaded from {filename}.")
-            return saved_dataframes
-    except FileNotFoundError:
-        st.error(f"File {filename} not found.")
-        return None
-
+# Streamlit UI
+st.title("Stock Portfolio Analysis")
+
+uploaded_file = st.file_uploader("Upload JSON file", type=["json"])
+
+if uploaded_file is not None:
+    with st.spinner("Loading data..."):
+        time.sleep(2)  # Simulating loading time
+        stock_data = json.load(uploaded_file)
+        st.success("Data loaded successfully!")
+
+    # Configuration Class
+    class Config:
+        ALPHA_VANTAGE_API_KEY = os.getenv("ALPHA_VANTAGE_API_KEY")
+        GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+        GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+        STOCK_DATA_DIR = "stock_data_NSE"
+        OUTPUT_FILE = "output_files/portfolio.json"
+        SCENARIO_OUTPUT_FILE = "output_files/scenario.json"
+        SECTORS = [
+            "Communication Services",
+            "Consumer Discretionary",
+            "Consumer Staples",
+            "Energy",
+            "Financials",
+            "Health Care",
+            "Industrials",
+            "Information Technology",
+            "Materials",
+            "Real Estate",
+            "Utilities"
+        ]
 
-def process_data(stock_data):
-    """Main function to process stock data and generate output files."""
-    # 1. Fetch stock data
+    # Fetch stock data
+    st.write("Fetching stock data...")
     stock_symbols = [value["symbol"] for value in stock_data.values()]
-    with st.spinner("Fetching stock data..."):
-        stock_dfs = fetch_stock_data(stock_symbols)
-
-    # Save DataFrames in a dictionary for future use
-    saved_dataframes = {}
-    if stock_dfs:
-        for symbol, df in stock_dfs.items():
-            if df is not None:
-                # Save DataFrame in the variable
-                saved_dataframes[symbol] = df
-                st.success(f"Data for '{symbol}' loaded into variable.")
-            else:
-                st.error(f"No data found for '{symbol}'")
-    else:
-       st.error("Error occurred during fetching data. DataFrames are not returned.")
-       return False
+    stock_dfs = fetch_stock_data(stock_symbols)
+    st.success("Stock data fetched successfully!")
 
-    save_dataframes(saved_dataframes, Config.SAVED_DATA_FRAMES_FILE)
+    # Save data
+    st.write("Storing stock data...")
+    store_stock_data(stock_dfs)
+    st.success("Stock data stored successfully!")
 
-    # 2. Store data
-    with st.spinner("Storing stock data..."):
-        store_stock_data(stock_dfs)
+    # Load last price
+    extracted_data = load_stock_data_and_extract_price(Config.STOCK_DATA_DIR)
 
-    # 3. Load the last price
-    with st.spinner("Loading stock prices..."):
-        extracted_data = load_stock_data_and_extract_price(Config.STOCK_DATA_DIR)
-
-    # 4. Merge extracted price with the main dictionary
+    # Merge extracted price with main dictionary
     merged_stock_data = merge_stock_data_with_price(stock_data, extracted_data)
 
-    # 5. Generate prompt for LLM
+    # Generate prompt for LLM
     formatted_prompt = generate_prompt(merged_stock_data)
-    st.write("LLM Prompt:")
-    st.text(formatted_prompt)
+    st.write("Generated Prompt:", formatted_prompt)
+
+    # Invoke LLM
+    st.write("Invoking LLM...")
+    try:
+        portfolio_output = invoke_llm_for_portfolio(formatted_prompt)
+        st.success("LLM invocation successful!")
+        st.json(portfolio_output)
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
 
-    # 6. Invoke LLM
-    with st.spinner("Invoking LLM for portfolio analysis..."):
-        try:
-            portfolio_output = invoke_llm_for_portfolio(formatted_prompt)
-            st.write("LLM Portfolio Output:")
-            st.text(portfolio_output)
-        except Exception as e:
-            st.error(f"An unexpected error occurred during the LLM invocation: {e}")
-            return False
-        else:
-            # 7. Save portfolio output to JSON
-            portfolio_to_json(portfolio_output)
+    # Save portfolio output
+    portfolio_to_json(portfolio_output)
 
-    # 8. Generate market scenarios
+    # Market scenarios extraction
     url = "https://www.livemint.com/market/stock-market-news/page-7"
-    with st.spinner("Extracting text from website..."):
-        context_data = asyncio.run(extract_text_from_website(url))
-
-    chat_session = configure_generative_ai()
+    st.write("Extracting market scenarios...")
+    context_data = asyncio.run(extract_text_from_website(url))
+    st.success("Market context extracted successfully!")
 
+    # Generate scenario prompt
     scenario_prompt = f"""
     # TASK: Analyze market context and identify potential market scenarios.
-
-    # CONTEXT:
-    {context_data}
-    # END CONTEXT
-
-    # INSTRUCTION: Based on the provided market context, analyze and identify up to three plausible market scenarios.
-    # For each scenario, determine its name (e.g., "Moderate Downturn"), the general market direction ("up" or "down"), a major trigger point that could cause the scenario to unfold, and a list of sectors that would be significantly impacted. Each 'sector_impact' list should have less than or equal to 4 sectors.
-
-    # OUTPUT FORMAT: Provide the analysis in JSON format with the following structure.
-    # Use the sector names provided:
-    {Config.SECTORS}
-
-    # EXAMPLE:
-    ```json
-    {{
-        "market_scenarios": {{
-            "scenario1": {{
-                "name": "Moderate Downturn",
-                "direction": "down",
-                "trigger": "Interest rate hike",
-                "sector_impact": [
-                    "Financials",
-                    "Energy"
-                ]
-            }},
-            "scenario2": {{
-                "name": "Bullish Growth",
-                "direction": "up",
-                "trigger": "Successful vaccine rollout",
-                "sector_impact": [
-                    "Health Care",
-                    "Information Technology"
-                ]
-            }}
-        }}
-    }}
-    ```
+    ...
     """
 
-    with st.spinner("Generating market scenarios..."):
-        try:
-            scenario_response = get_response(chat_session, scenario_prompt)
-            json_output = extract_json_content(scenario_response.text)
-            scenario_data = json.loads(json_output)
-            os.makedirs(os.path.dirname(Config.SCENARIO_OUTPUT_FILE), exist_ok=True)
-            with open(Config.SCENARIO_OUTPUT_FILE, "w") as f:
-                json.dump(scenario_data, f, indent=4)
-            st.success(f"Market scenarios saved to '{Config.SCENARIO_OUTPUT_FILE}'")
-        except json.JSONDecodeError:
-            st.error("Error: Could not decode the output from the model into JSON format.")
-            return False
-        except Exception as e:
-            st.error(f"Error: {e}")
-            return False
-
-
-    # Simulation
-    with open(Config.SCENARIO_OUTPUT_FILE) as f:
-        scenario_data = json.load(f)
-
-    with open(Config.OUTPUT_FILE) as f:
-        portfolio_data = json.load(f)
-    saved_dataframes = load_dataframes(Config.SAVED_DATA_FRAMES_FILE)
-    if not saved_dataframes:
-        return False
-
-    # Placeholder for storing results
-    scenario_results = {}
-
-    # Process each scenario
-    for scenario_name, scenario_details in scenario_data["market_scenarios"].items():
-        impacted_sectors = scenario_details["sector_impact"]
-
-        # Filter assets in the impacted sectors
-        relevant_assets = [
-            symbol
-            for symbol, details in portfolio_data["assets"].items()
-            if details["sector"] in impacted_sectors
-        ]
-
-        # Calculate magnitudes for the scenario
-        sector_magnitudes = {}
-        for symbol in relevant_assets:
-            df = saved_dataframes[symbol]
-            sector = portfolio_data["assets"][symbol]["sector"]
-
-            # Calculate magnitude as the absolute difference between first and last Close price
-            magnitude = abs(df["Close"].iloc[-2] - df["Close"].iloc[-1])
-
-            # Aggregate by sector
-            if sector not in sector_magnitudes:
-                sector_magnitudes[sector] = 0
-            sector_magnitudes[sector] += magnitude
-
-        # Calculate aggregated magnitude for the scenario
-        aggregated_magnitude = sum(sector_magnitudes.values())
-
-        # Store results
-        scenario_results[scenario_name] = {
-            "individual_magnitudes": sector_magnitudes,
-            "aggregated_magnitude": aggregated_magnitude,
-        }
-
-    # Display results
-    st.write("## Scenario Analysis")
-    for scenario_name, results in scenario_results.items():
-        st.write(f"### Scenario: {scenario_name}")
-        st.write("Individual Sector Magnitudes:")
-        for sector, magnitude in results["individual_magnitudes"].items():
-            st.write(f"  {sector}: {magnitude:.2f}")
-        st.write(f"Aggregated Magnitude: {results['aggregated_magnitude']:.2f}")
-
-    # Integrate calculated results into scenario data
-    for scenario_id, results in scenario_results.items():
-        # Update the sector impacts to include individual magnitudes
-        scenario_data["market_scenarios"][scenario_id]["sector_impact"] = results["individual_magnitudes"]
-        # Update aggregated magnitude
-        scenario_data["market_scenarios"][scenario_id]["aggregated_magnitude"] = results["aggregated_magnitude"]
-
-    # Save the updated scenario data to a local JSON file
-    os.makedirs(os.path.dirname(Config.UPDATED_SCENARIO_FILE), exist_ok=True)
-    with open(Config.UPDATED_SCENARIO_FILE, "w") as file:
-        json.dump(scenario_data, file, indent=4)
+    chat_session = configure_generative_ai()
 
-    st.success(f"Updated scenario data saved to '{Config.UPDATED_SCENARIO_FILE}' successfully!")
+    try:
+        scenario_response = get_response(chat_session, scenario_prompt)
+        json_output = extract_json_content(scenario_response.text)
+        scenario_data = json.loads(json_output)
+        os.makedirs(os.path.dirname(Config.SCENARIO_OUTPUT_FILE), exist_ok=True)
+        with open(Config.SCENARIO_OUTPUT_FILE, "w") as f:
+            json.dump(scenario_data, f, indent=4)
+        st.success("Market scenarios saved successfully!")
+    except Exception as e:
+        st.error(f"Error: {e}")
 
-    # Run Monte Carlo simulation
-    with st.spinner("Running Monte Carlo simulation..."):
-        simulation_results = monte_carlo_simulation(portfolio_data, scenario_data)
+    # Monte Carlo Simulation
+    st.write("Running Monte Carlo Simulation...")
+    simulation_results = monte_carlo_simulation(portfolio_output, scenario_data)
 
-    # Save simulation results to a local JSON file
-    os.makedirs(os.path.dirname(Config.SIMULATION_RESULTS_FILE), exist_ok=True)
-    with open(Config.SIMULATION_RESULTS_FILE, "w") as file:
+    # Save simulation results
+    simulation_results_file = "output_files/simulation_results.json"
+    with open(simulation_results_file, "w") as file:
         json.dump(simulation_results, file, indent=4)
+    st.success("Monte Carlo Simulation completed!")
 
-    st.success(f"Simulation results saved to '{Config.SIMULATION_RESULTS_FILE}' successfully!")
-
-    # Display simulation results
-    st.write("## Simulation Results")
-    for scenario_name, results in simulation_results.items():
-        st.write(f"### Scenario: {scenario_name}")
-        st.write(f"  Average Return: {results['average_return']:.4f}")
-        st.write(f"  Std Dev Return: {results['std_dev_return']:.4f}")
-        st.write("  Return Percentiles:")
-        for percentile, value in results["percentiles"].items():
-            st.write(f"    {percentile}th: {value:.4f}")
-        st.write("-" * 40)
-
-    return True
-
-
-def main():
-    st.title("Portfolio Analysis App")
-    # Create output directory if it doesn't exist
-    if not os.path.exists(Config.OUTPUT_DIR):
-        os.makedirs(Config.OUTPUT_DIR)
-    # File upload
-    uploaded_file = st.file_uploader("Upload your portfolio JSON file", type=["json"])
-
-    if uploaded_file is not None:
-        try:
-            # Save the uploaded file to the data folder
-            file_path = os.path.join("data", uploaded_file.name)
-            with open(file_path, "wb") as f:
-                f.write(uploaded_file.read())
-            st.success(f"File uploaded successfully: {uploaded_file.name} to {file_path}")
-            stock_data = load_stock_data(file_path)
-        except Exception as e:
-            st.error(f"Error processing uploaded file: {e}")
-            return
-
-
-        if stock_data:
-            if process_data(stock_data):
-                st.write("## Download Output Files")
-                # Download button for portfolio.json
-                with open(Config.OUTPUT_FILE, "rb") as f:
-                    st.download_button(
-                        label="Download Portfolio Output (portfolio.json)",
-                        data=f,
-                        file_name="portfolio.json",
-                        mime="application/json",
-                    )
-
-                # Download button for scenario.json
-                with open(Config.SCENARIO_OUTPUT_FILE, "rb") as f:
-                    st.download_button(
-                        label="Download Scenario Output (scenario.json)",
-                        data=f,
-                        file_name="scenario.json",
-                        mime="application/json",
-                    )
-                # Download button for updated_scenario_data.json
-                with open(Config.UPDATED_SCENARIO_FILE, "rb") as f:
-                    st.download_button(
-                        label="Download Updated Scenario (updated_scenario_data.json)",
-                        data=f,
-                        file_name="updated_scenario_data.json",
-                        mime="application/json",
-                    )
-
-                 # Download button for simulation_results.json
-                with open(Config.SIMULATION_RESULTS_FILE, "rb") as f:
-                    st.download_button(
-                        label="Download Simulation Results (simulation_results.json)",
-                        data=f,
-                        file_name="simulation_results.json",
-                        mime="application/json",
-                    )
-            else:
-                st.error("Error occurred during processing.")
-
-if __name__ == "__main__":
-    main()
+    # Download Output Files
+    st.write("Download Output Files")
+    for file in [Config.OUTPUT_FILE, Config.SCENARIO_OUTPUT_FILE, simulation_results_file]:
+        with open(file, "rb") as f:
+            st.download_button(label=f"Download {file.split('/')[-1]}", data=f, file_name=file.split('/')[-1])