Create app.py

app.py

@@ -0,0 +1,397 @@
+import streamlit as st
+import os
+import json
+import pickle
+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,
+    load_stock_data_and_extract_price,
+    portfolio_to_json,
+    merge_stock_data_with_price,
+    generate_prompt,
+    invoke_llm_for_portfolio
+)
+from scenario import (
+    extract_text_from_website,
+    get_response,
+    extract_json_content
+)
+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
+
+
+def process_data(stock_data):
+    """Main function to process stock data and generate output files."""
+    # 1. Fetch 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
+
+    save_dataframes(saved_dataframes, Config.SAVED_DATA_FRAMES_FILE)
+
+    # 2. Store data
+    with st.spinner("Storing stock data..."):
+        store_stock_data(stock_dfs)
+
+    # 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
+    merged_stock_data = merge_stock_data_with_price(stock_data, extracted_data)
+
+    # 5. Generate prompt for LLM
+    formatted_prompt = generate_prompt(merged_stock_data)
+    st.write("LLM Prompt:")
+    st.text(formatted_prompt)
+
+    # 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)
+
+    # 8. Generate market scenarios
+    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()
+
+    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)
+
+    st.success(f"Updated scenario data saved to '{Config.UPDATED_SCENARIO_FILE}' successfully!")
+
+    # Run Monte Carlo simulation
+    with st.spinner("Running Monte Carlo simulation..."):
+        simulation_results = monte_carlo_simulation(portfolio_data, 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:
+        json.dump(simulation_results, file, indent=4)
+
+    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()