hedge_fund_trading_team.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "iUylmr_b4IaC",
        "-adeYrdHpHvx",
        "2pUu92rT4E0f",
        "-nGZT2kk4idn",
        "gzOlyDJe4nsv",
        "TcKHO2SE4tFQ",
        "DsvZo7gjpMGu",
        "eib4alsrpQ3h",
        "8gbjCJT-pTa0"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Edu963/python_projects/blob/main/hedge_fund_trading_team.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 0. Setup"
      ],
      "metadata": {
        "id": "iUylmr_b4IaC"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jDTXcDmUj0bV"
      },
      "outputs": [],
      "source": [
        "!pip install -U --quiet langgraph langchain_openai"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import getpass\n",
        "import os\n",
        "\n",
        "\n",
        "def _set_if_undefined(var: str):\n",
        "    if not os.environ.get(var):\n",
        "        os.environ[var] = getpass.getpass(f\"Please provide your {var}\")\n",
        "\n",
        "\n",
        "_set_if_undefined(\"OPENAI_API_KEY\")               # For calling LLM. Get from https://platform.openai.com/\n",
        "_set_if_undefined(\"FINANCIAL_DATASETS_API_KEY\")   # For getting financial data. Get from https://financialdatasets.ai"
      ],
      "metadata": {
        "id": "azDJXqYSl2sF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "import pandas as pd\n",
        "import requests\n",
        "import os\n",
        "from datetime import timedelta\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Import your agent's dependencies\n",
        "from langchain_openai.chat_models import ChatOpenAI\n",
        "from langchain_core.messages import HumanMessage, SystemMessage\n",
        "from langgraph.graph import END, MessagesState, StateGraph, START\n",
        "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
        "from langchain_core.output_parsers import JsonOutputParser\n",
        "from pydantic import BaseModel, Field\n",
        "from typing import Literal"
      ],
      "metadata": {
        "id": "lP3IylZfm744"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# We use GPT-4o, but you can use any LLM\n",
        "llm = ChatOpenAI(model=\"gpt-4o\")"
      ],
      "metadata": {
        "id": "lKZO15gm3-El"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Create Market Data Agent"
      ],
      "metadata": {
        "id": "-adeYrdHpHvx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def market_data_agent(state: MessagesState):\n",
        "    \"\"\"Responsible for gathering and preprocessing market data\"\"\"\n",
        "    messages = state[\"messages\"]\n",
        "    params = messages[-1].additional_kwargs\n",
        "\n",
        "    # Get the historical price data\n",
        "    historical_data = get_price_data(\n",
        "        params[\"ticker\"], params[\"start_date\"], params[\"end_date\"]\n",
        "    )\n",
        "\n",
        "    # Calculate the trading signals\n",
        "    signals = calculate_trading_signals(historical_data)\n",
        "\n",
        "    # Create the market data agent's message using the signals and historical data\n",
        "    message = HumanMessage(\n",
        "        content=f\"\"\"\n",
        "        Here are the trading signals for {params[\"ticker\"]}:\n",
        "        Current Price: ${signals['current_price']:.2f}\n",
        "        SMA 5: {signals['sma_5_curr']:.2f}\n",
        "        SMA 5 Previous: {signals['sma_5_prev']:.2f}\n",
        "        SMA 20: {signals['sma_20_curr']:.2f}\n",
        "        SMA 20 Previous: {signals['sma_20_prev']:.2f}\n",
        "        \"\"\",\n",
        "        name=\"market_data_agent\",\n",
        "    )\n",
        "\n",
        "    return {\"messages\": messages + [message]}"
      ],
      "metadata": {
        "id": "tuMK7Jrxj3eY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Create Quant Agent"
      ],
      "metadata": {
        "id": "2pUu92rT4E0f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def quant_agent(state: MessagesState):\n",
        "    \"\"\"Analyzes technical indicators and generates trading signals\"\"\"\n",
        "    last_message = state[\"messages\"][-1]\n",
        "\n",
        "    summary_prompt = ChatPromptTemplate.from_messages(\n",
        "        [\n",
        "            (\n",
        "                \"system\",\n",
        "                \"\"\"You are a hedge fund quant / technical analyst.\n",
        "                You are given trading signals for a stock.\n",
        "                Analyze the signals and provide a recommendation.\n",
        "                - signal: bullish | bearish | neutral,\n",
        "                - confidence: <float between 0 and 1>\n",
        "                \"\"\"\n",
        "            ),\n",
        "            MessagesPlaceholder(variable_name=\"messages\"),\n",
        "            (\n",
        "                \"human\",\n",
        "                f\"\"\"Based on the trading signals below, analyze the data and provide your assessment.\n",
        "\n",
        "                Trading Analysis: {last_message.content}\n",
        "\n",
        "                Only include your trading signal and confidence in the output.\n",
        "                \"\"\"\n",
        "            ),\n",
        "        ]\n",
        "    )\n",
        "\n",
        "    chain = summary_prompt | llm\n",
        "\n",
        "    result = chain.invoke(state).content\n",
        "    message = HumanMessage(\n",
        "        content=f\"Here is the trading analysis and my recommendation:{result}\",\n",
        "        name=\"quant_agent\",\n",
        "    )\n",
        "\n",
        "    return {\"messages\": state[\"messages\"] + [message]}\n"
      ],
      "metadata": {
        "id": "UnlmOdL8j7QD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3. Create Risk Management Agent"
      ],
      "metadata": {
        "id": "-nGZT2kk4idn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def risk_management_agent(state: MessagesState):\n",
        "    \"\"\"Evaluates portfolio risk and sets position limits\"\"\"\n",
        "    portfolio = state[\"messages\"][0].additional_kwargs[\"portfolio\"]\n",
        "    last_message = state[\"messages\"][-1]\n",
        "\n",
        "    risk_prompt = ChatPromptTemplate.from_messages(\n",
        "        [\n",
        "            (\n",
        "                \"system\",\n",
        "                \"\"\"You are a risk management specialist.\n",
        "                Your job is to take a look at the trading analysis and\n",
        "                evaluate portfolio exposure and recommend position sizing.\n",
        "                Provide the following in your output (not as a JSON):\n",
        "                - max_position_size: <float greater than 0>,\n",
        "                - risk_score: <integer between 1 and 10>\"\"\"\n",
        "            ),\n",
        "            MessagesPlaceholder(variable_name=\"messages\"),\n",
        "            (\n",
        "                \"human\",\n",
        "                f\"\"\"Based on the trading analysis below, provide your risk assessment.\n",
        "\n",
        "                Trading Analysis: {last_message.content}\n",
        "\n",
        "                Here is the current portfolio:\n",
        "                Portfolio:\n",
        "                Cash: ${portfolio['cash']:.2f}\n",
        "                Current Position: {portfolio['stock']} shares\n",
        "\n",
        "                Only include the max position size and risk score in your output.\n",
        "                \"\"\"\n",
        "            ),\n",
        "        ]\n",
        "    )\n",
        "    chain = risk_prompt | llm\n",
        "    result = chain.invoke(state).content\n",
        "    message = HumanMessage(\n",
        "        content=f\"Here is the risk management recommendation: {result}\",\n",
        "        name=\"risk_management\",\n",
        "    )\n",
        "    return {\"messages\": state[\"messages\"] + [message]}"
      ],
      "metadata": {
        "id": "Q6NTMMzG4k2z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4. Create Portfolio Management Agent"
      ],
      "metadata": {
        "id": "gzOlyDJe4nsv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def portfolio_management_agent(state: MessagesState):\n",
        "    \"\"\"Makes final trading decisions and generates orders\"\"\"\n",
        "    portfolio = state[\"messages\"][0].additional_kwargs[\"portfolio\"]\n",
        "    last_message = state[\"messages\"][-1]\n",
        "\n",
        "    portfolio_prompt = ChatPromptTemplate.from_messages(\n",
        "        [\n",
        "            (\n",
        "                \"system\",\n",
        "                \"\"\"You are a portfolio manager making final trading decisions.\n",
        "                Your job is to make a trading decision based on the risk management data.\n",
        "                Provide the following in your output:\n",
        "                - \"action\": \"buy\" | \"sell\" | \"hold\",\n",
        "                - \"quantity\": <positive integer>\n",
        "                Only buy if you have available cash.\n",
        "                The quantity that you buy must be less than or equal to the max position size.\n",
        "                Only sell if you have shares in the portfolio to sell.\n",
        "                The quantity that you sell must be less than or equal to the current position.\"\"\"\n",
        "            ),\n",
        "            MessagesPlaceholder(variable_name=\"messages\"),\n",
        "            (\n",
        "                \"human\",\n",
        "                f\"\"\"Based on the risk management data below, make your trading decision.\n",
        "\n",
        "                Risk Management Data: {last_message.content}\n",
        "\n",
        "                Here is the current portfolio:\n",
        "                Portfolio:\n",
        "                Cash: ${portfolio['cash']:.2f}\n",
        "                Current Position: {portfolio['stock']} shares\n",
        "\n",
        "                Only include the action and quantity.\n",
        "\n",
        "                Remember, the action must be either buy, sell, or hold.\n",
        "                You can only buy if you have available cash.\n",
        "                You can only sell if you have shares in the portfolio to sell.\n",
        "                \"\"\"\n",
        "            ),\n",
        "        ]\n",
        "    )\n",
        "\n",
        "    chain = portfolio_prompt | llm\n",
        "    result = chain.invoke(state).content\n",
        "    return {\"messages\": [HumanMessage(content=result, name=\"portfolio_management\")]}"
      ],
      "metadata": {
        "id": "H8es_WTx4rMl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5. Create Agent Graph"
      ],
      "metadata": {
        "id": "TcKHO2SE4tFQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the new workflow\n",
        "workflow = StateGraph(MessagesState)\n",
        "\n",
        "# Add nodes\n",
        "workflow.add_node(\"market_data_agent\", market_data_agent)\n",
        "workflow.add_node(\"quant_agent\", quant_agent)\n",
        "workflow.add_node(\"risk_management_agent\", risk_management_agent)\n",
        "workflow.add_node(\"portfolio_management_agent\", portfolio_management_agent)\n",
        "\n",
        "# Define the workflow\n",
        "workflow.add_edge(START, \"market_data_agent\")\n",
        "workflow.add_edge(\"market_data_agent\", \"quant_agent\")\n",
        "workflow.add_edge(\"quant_agent\", \"risk_management_agent\")\n",
        "workflow.add_edge(\"risk_management_agent\", \"portfolio_management_agent\")\n",
        "workflow.add_edge(\"portfolio_management_agent\", END)\n",
        "\n",
        "app = workflow.compile()"
      ],
      "metadata": {
        "id": "YC4AJM244wb3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Update the run_agent function to include portfolio state\n",
        "def run_agent(ticker: str, start_date: str, end_date: str, portfolio: dict):\n",
        "    final_state = app.invoke(\n",
        "        {\n",
        "            \"messages\": [\n",
        "                HumanMessage(\n",
        "                    content=\"Make a trading decision based on the provided data.\",\n",
        "                    additional_kwargs={\n",
        "                        \"ticker\": ticker,\n",
        "                        \"start_date\": start_date,\n",
        "                        \"end_date\": end_date,\n",
        "                        \"portfolio\": portfolio\n",
        "                    },\n",
        "                )\n",
        "            ]\n",
        "        },\n",
        "        config={\"configurable\": {\"thread_id\": 42}},\n",
        "    )\n",
        "    return final_state[\"messages\"][-1].content\n"
      ],
      "metadata": {
        "id": "J8ex59k84zOj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 6. Get Stock Price and Trading Signals"
      ],
      "metadata": {
        "id": "DsvZo7gjpMGu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a function to calculate trading signals\n",
        "def calculate_trading_signals(historical_data: pd.DataFrame) -> dict:\n",
        "    \"\"\"Calculate trading signals based on SMA crossover strategy\"\"\"\n",
        "    # Calculate SMAs\n",
        "    sma_5 = historical_data[\"close\"].rolling(window=5).mean()\n",
        "    sma_20 = historical_data[\"close\"].rolling(window=20).mean()\n",
        "\n",
        "    # Get the last two points of each SMA to check for crossover\n",
        "    sma_5_prev, sma_5_curr = sma_5.iloc[-2:]\n",
        "    sma_20_prev, sma_20_curr = sma_20.iloc[-2:]\n",
        "\n",
        "    return {\n",
        "        \"current_price\": historical_data[\"close\"].iloc[-1],\n",
        "        \"sma_5_curr\": sma_5_curr,\n",
        "        \"sma_5_prev\": sma_5_prev,\n",
        "        \"sma_20_curr\": sma_20_curr,\n",
        "        \"sma_20_prev\": sma_20_prev,\n",
        "    }"
      ],
      "metadata": {
        "id": "25BbhA_FKj3k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Move the price data fetching function into the agent's scope\n",
        "def get_price_data(ticker, start_date, end_date):\n",
        "    # Add your API key to the headers\n",
        "    headers = {\"X-API-KEY\": os.environ.get(\"FINANCIAL_DATASETS_API_KEY\")}\n",
        "\n",
        "    # Create the URL\n",
        "    url = (\n",
        "        f\"https://api.financialdatasets.ai/prices/\"\n",
        "        f\"?ticker={ticker}\"\n",
        "        f\"&interval=day\"\n",
        "        f\"&interval_multiplier=1\"\n",
        "        f\"&start_date={start_date}\"\n",
        "        f\"&end_date={end_date}\"\n",
        "    )\n",
        "\n",
        "    # Make API request\n",
        "    response = requests.get(url, headers=headers)\n",
        "\n",
        "    # Check for successful response\n",
        "    if response.status_code != 200:\n",
        "        raise Exception(\n",
        "            f\"Error fetching data: {response.status_code} - {response.text}\"\n",
        "        )\n",
        "\n",
        "    # Parse prices from the response\n",
        "    data = response.json()\n",
        "    prices = data.get(\"prices\")\n",
        "    if not prices:\n",
        "        raise ValueError(\"No price data returned\")\n",
        "\n",
        "    # Convert prices to DataFrame\n",
        "    df = pd.DataFrame(prices)\n",
        "\n",
        "    # Convert 'time' to datetime and set as index\n",
        "    df[\"Date\"] = pd.to_datetime(df[\"time\"])\n",
        "    df.set_index(\"Date\", inplace=True)\n",
        "\n",
        "    # Ensure numeric data types\n",
        "    numeric_cols = [\"open\", \"close\", \"high\", \"low\", \"volume\"]\n",
        "    for col in numeric_cols:\n",
        "        df[col] = pd.to_numeric(df[col], errors=\"coerce\")\n",
        "\n",
        "    # Sort by date\n",
        "    df.sort_index(inplace=True)\n",
        "\n",
        "    return df"
      ],
      "metadata": {
        "id": "j4wMlB_y49_I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 7. Create Backtester"
      ],
      "metadata": {
        "id": "eib4alsrpQ3h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Backtester:\n",
        "    def __init__(self, agent, ticker, start_date, end_date, initial_capital):\n",
        "        self.agent = agent\n",
        "        self.ticker = ticker\n",
        "        self.start_date = start_date\n",
        "        self.end_date = end_date\n",
        "        self.initial_capital = initial_capital\n",
        "        self.portfolio = {\"cash\": initial_capital, \"stock\": 0}\n",
        "        self.portfolio_values = []\n",
        "\n",
        "    def parse_action(self, agent_output):\n",
        "        try:\n",
        "            # Expect JSON output from agent\n",
        "            import json\n",
        "            decision = json.loads(agent_output)\n",
        "            return decision[\"action\"], decision[\"quantity\"]\n",
        "        except:\n",
        "            return \"hold\", 0\n",
        "\n",
        "    def execute_trade(self, action, quantity, current_price):\n",
        "        \"\"\"Validate and execute trades based on portfolio constraints\"\"\"\n",
        "        if action == \"buy\" and quantity > 0:\n",
        "            cost = quantity * current_price\n",
        "            if cost <= self.portfolio[\"cash\"]:\n",
        "                self.portfolio[\"stock\"] += quantity\n",
        "                self.portfolio[\"cash\"] -= cost\n",
        "                return quantity\n",
        "            else:\n",
        "                # Calculate maximum affordable quantity\n",
        "                max_quantity = self.portfolio[\"cash\"] // current_price\n",
        "                if max_quantity > 0:\n",
        "                    self.portfolio[\"stock\"] += max_quantity\n",
        "                    self.portfolio[\"cash\"] -= max_quantity * current_price\n",
        "                    return max_quantity\n",
        "                return 0\n",
        "        elif action == \"sell\" and quantity > 0:\n",
        "            quantity = min(quantity, self.portfolio[\"stock\"])\n",
        "            if quantity > 0:\n",
        "                self.portfolio[\"cash\"] += quantity * current_price\n",
        "                self.portfolio[\"stock\"] -= quantity\n",
        "                return quantity\n",
        "            return 0\n",
        "        return 0\n",
        "\n",
        "    def run_backtest(self):\n",
        "        dates = pd.date_range(self.start_date, self.end_date, freq=\"B\")\n",
        "\n",
        "        print(\"\\nStarting backtest...\")\n",
        "        print(f\"{'Date':<12} {'Action':<6} {'Quantity':>8} {'Price':>8} {'Cash':>12} {'Stock':>8} {'Total Value':>12}\")\n",
        "        print(\"-\" * 70)\n",
        "\n",
        "        for current_date in dates:\n",
        "            lookback_start = (current_date - timedelta(days=30)).strftime(\"%Y-%m-%d\")\n",
        "            current_date_str = current_date.strftime(\"%Y-%m-%d\")\n",
        "\n",
        "            agent_output = self.agent(\n",
        "                ticker=self.ticker,\n",
        "                start_date=lookback_start,\n",
        "                end_date=current_date_str,\n",
        "                portfolio=self.portfolio\n",
        "            )\n",
        "\n",
        "            action, quantity = self.parse_action(agent_output)\n",
        "            df = get_price_data(self.ticker, lookback_start, current_date_str)\n",
        "            current_price = df.iloc[-1]['close']\n",
        "\n",
        "            # Execute the trade with validation\n",
        "            executed_quantity = self.execute_trade(action, quantity, current_price)\n",
        "\n",
        "            # Update total portfolio value\n",
        "            total_value = self.portfolio[\"cash\"] + self.portfolio[\"stock\"] * current_price\n",
        "            self.portfolio[\"portfolio_value\"] = total_value\n",
        "\n",
        "            # Log the current state with executed quantity\n",
        "            print(\n",
        "                f\"{current_date.strftime('%Y-%m-%d'):<12} {action:<6} {executed_quantity:>8} {current_price:>8.2f} \"\n",
        "                f\"{self.portfolio['cash']:>12.2f} {self.portfolio['stock']:>8} {total_value:>12.2f}\"\n",
        "            )\n",
        "\n",
        "            # Record the portfolio value\n",
        "            self.portfolio_values.append(\n",
        "                {\"Date\": current_date, \"Portfolio Value\": total_value}\n",
        "            )\n",
        "\n",
        "    def analyze_performance(self):\n",
        "        # Convert portfolio values to DataFrame\n",
        "        performance_df = pd.DataFrame(self.portfolio_values).set_index(\"Date\")\n",
        "\n",
        "        # Calculate total return\n",
        "        total_return = (\n",
        "                           self.portfolio[\"portfolio_value\"] - self.initial_capital\n",
        "                       ) / self.initial_capital\n",
        "        print(f\"Total Return: {total_return * 100:.2f}%\")\n",
        "\n",
        "        # Plot the portfolio value over time\n",
        "        performance_df[\"Portfolio Value\"].plot(\n",
        "            title=\"Portfolio Value Over Time\", figsize=(12, 6)\n",
        "        )\n",
        "        plt.ylabel(\"Portfolio Value ($)\")\n",
        "        plt.xlabel(\"Date\")\n",
        "        plt.show()\n",
        "\n",
        "        # Compute daily returns\n",
        "        performance_df[\"Daily Return\"] = performance_df[\"Portfolio Value\"].pct_change()\n",
        "\n",
        "        # Calculate Sharpe Ratio (assuming 252 trading days in a year)\n",
        "        mean_daily_return = performance_df[\"Daily Return\"].mean()\n",
        "        std_daily_return = performance_df[\"Daily Return\"].std()\n",
        "        sharpe_ratio = (mean_daily_return / std_daily_return) * (252 ** 0.5)\n",
        "        print(f\"Sharpe Ratio: {sharpe_ratio:.2f}\")\n",
        "\n",
        "        # Calculate Maximum Drawdown\n",
        "        rolling_max = performance_df[\"Portfolio Value\"].cummax()\n",
        "        drawdown = performance_df[\"Portfolio Value\"] / rolling_max - 1\n",
        "        max_drawdown = drawdown.min()\n",
        "        print(f\"Maximum Drawdown: {max_drawdown * 100:.2f}%\")\n",
        "\n",
        "        return performance_df\n"
      ],
      "metadata": {
        "id": "sycJCgYunBfq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 8. Run the Backtest"
      ],
      "metadata": {
        "id": "8gbjCJT-pTa0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define parameters\n",
        "ticker = \"AAPL\"  # Example ticker symbol\n",
        "start_date = \"2024-01-01\"  # Adjust as needed\n",
        "end_date = \"2024-11-23\"  # Adjust as needed\n",
        "initial_capital = 100000  # $100,000\n",
        "\n",
        "# Create an instance of Backtester\n",
        "backtester = Backtester(\n",
        "    agent=run_agent,\n",
        "    ticker=ticker,\n",
        "    start_date=start_date,\n",
        "    end_date=end_date,\n",
        "    initial_capital=initial_capital,\n",
        ")\n",
        "\n",
        "# Run the backtesting process\n",
        "backtester.run_backtest()\n",
        "performance_df = backtester.analyze_performance()"
      ],
      "metadata": {
        "id": "ro6_juA_nHl-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3qmllXP2kMH4"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}