gordon_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T00:36:16.420333270Z",
     "start_time": "2023-12-25T00:36:16.273133431Z"
    }
   },
   "source": [
    "import pandas as pd\n",
    "from selenium.webdriver import Keys\n",
    "from selenium.webdriver.common.by import By\n",
    "from selenium.webdriver.support.wait import WebDriverWait"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T00:11:27.601135136Z",
     "start_time": "2023-12-25T00:11:27.499981832Z"
    }
   },
   "source": [
    "from utils import get_tickers_from_market_index\n",
    "\n",
    "idiv = get_tickers_from_market_index(\"./assets/IDIV-composition.csv\")\n",
    "\n",
    "len(idiv)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T00:11:27.690254387Z",
     "start_time": "2023-12-25T00:11:27.584045857Z"
    }
   },
   "source": [
    "tickers_code = [f\"{ticker}.SA\" for ticker in idiv]\n",
    "tickers_code"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Obter os dados de dividendos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T00:11:28.056302796Z",
     "start_time": "2023-12-25T00:11:27.671687061Z"
    }
   },
   "source": [
    "import yfinance as yf\n",
    "\n",
    "tickers = yf.Tickers(tickers_code).tickers"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T00:12:11.733107080Z",
     "start_time": "2023-12-25T00:11:28.097158066Z"
    }
   },
   "source": [
    "all_dividends = pd.DataFrame()\n",
    "\n",
    "for ticker, data in tickers.items():\n",
    "    per_month_df = data.actions.groupby(pd.Grouper(freq=\"M\")).sum()\n",
    "    dividend_df = per_month_df.iloc[:, 0].to_frame()\n",
    "    dividend_df.rename(columns={'Dividends': ticker}, inplace=True)\n",
    "\n",
    "    if all_dividends.empty:\n",
    "        all_dividends = dividend_df\n",
    "        continue\n",
    "\n",
    "    all_dividends = all_dividends.merge(dividend_df, left_index=True, right_index=True, how='outer')\n",
    "    all_dividends.fillna(0, inplace=True)\n",
    "\n",
    "all_dividends.reset_index(inplace=True)\n",
    "all_dividends.set_index(\"Date\", inplace=True)\n",
    "all_dividends.index = pd.to_datetime(all_dividends.index)\n",
    "\n",
    "all_dividends"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T00:12:11.802793192Z",
     "start_time": "2023-12-25T00:12:11.732691412Z"
    }
   },
   "source": [
    "all_dividends.to_csv(\"./assets/idiv_companies_dividends.csv\")"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ## Agrupamento com base no dividendo\n",
    "\n",
    "Classificações:\n",
    "- Dividendo alto\n",
    "- Dividendo moderado\n",
    "- Dividendo baixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:39.812512877Z",
     "start_time": "2023-12-25T01:57:39.603932873Z"
    }
   },
   "source": [
    "all_dividends = pd.read_csv(\"./assets/idiv_companies_dividends.csv\")\n",
    "all_dividends.set_index(\"Date\", inplace=True)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:40.252435083Z",
     "start_time": "2023-12-25T01:57:40.091839997Z"
    }
   },
   "source": [
    "import plotly.express as px\n",
    "\n",
    "fig = px.line(all_dividends, x=all_dividends.index, y=all_dividends.columns[:5])\n",
    "fig.update_layout(title=\"Dividendo das empresas listados em bolsa\",\n",
    "                  xaxis_title=\"Data\",\n",
    "                  yaxis_title=\"Valor\")\n",
    "fig.show()"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:40.512065646Z",
     "start_time": "2023-12-25T01:57:40.265774103Z"
    }
   },
   "source": [
    "total_dividend = all_dividends.sum().to_frame(\"Dividend\")\n",
    "total_dividend"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:40.944645604Z",
     "start_time": "2023-12-25T01:57:40.533575924Z"
    }
   },
   "source": [
    "px.box(total_dividend)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:48.732178121Z",
     "start_time": "2023-12-25T01:57:40.796915873Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "\n",
    "mean = np.mean(total_dividend.Dividend)\n",
    "std_dev = np.std(total_dividend.Dividend)\n",
    "\n",
    "lower_fence = mean - 1.5 * std_dev\n",
    "upper_fence = mean + 1.5 * std_dev\n",
    "\n",
    "outliers = total_dividend[(total_dividend.Dividend < lower_fence) | (total_dividend.Dividend > upper_fence)]\n",
    "\n",
    "total_dividend.drop(outliers.index, inplace=True)\n",
    "total_dividend.sort_values(by=\"Dividend\", inplace=True)\n",
    "total_dividend"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:50.332136160Z",
     "start_time": "2023-12-25T01:57:48.737107608Z"
    }
   },
   "source": [
    "total_dividend.describe()"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:50.599679911Z",
     "start_time": "2023-12-25T01:57:50.315487562Z"
    }
   },
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "scaller = StandardScaler()\n",
    "total_dividend_scaled = scaller.fit_transform(total_dividend.to_numpy())\n",
    "total_dividend_scaled"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:51.151586581Z",
     "start_time": "2023-12-25T01:57:50.673495245Z"
    }
   },
   "source": [
    "from sklearn.cluster import KMeans\n",
    "\n",
    "cluster_model = KMeans(n_clusters=3, random_state=0)\n",
    "cluster_model.fit(total_dividend_scaled)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:51.154847919Z",
     "start_time": "2023-12-25T01:57:50.977926856Z"
    }
   },
   "source": [
    "centers = cluster_model.cluster_centers_\n",
    "centers = scaller.inverse_transform(centers).ravel()\n",
    "centers = sorted(centers)\n",
    "centers"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:51.295622638Z",
     "start_time": "2023-12-25T01:57:51.064412149Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "\n",
    "labels = cluster_model.labels_\n",
    "np.unique(np.array(labels), return_counts=True)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:51.454420154Z",
     "start_time": "2023-12-25T01:57:51.249140389Z"
    }
   },
   "source": [
    "import plotly.graph_objects as go\n",
    "\n",
    "classification_legend = [\n",
    "    \"Dividendos Baixo\",  # 0\n",
    "    \"Dividendos Moderado\",  # 1\n",
    "    \"Dividendos Alto\"  # 2\n",
    "]\n",
    "\n",
    "graph1 = px.scatter(total_dividend, x=total_dividend.index, y=total_dividend.columns, color=labels)\n",
    "graph2 = px.scatter(x=classification_legend, y=centers, size=[12, 12, 12])\n",
    "graph3 = go.Figure(data=graph1.data + graph2.data)\n",
    "graph3.show()"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:51.534043337Z",
     "start_time": "2023-12-25T01:57:51.406011865Z"
    }
   },
   "source": [
    "classification = np.column_stack((total_dividend, labels))\n",
    "classification_df = pd.DataFrame(classification, columns=[\"Dividend\", \"Classification\"])"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:51.649423546Z",
     "start_time": "2023-12-25T01:57:51.511300625Z"
    }
   },
   "source": [
    "classified_all_dividends = pd.merge(total_dividend, classification_df, on=\"Dividend\", how=\"left\")\n",
    "classified_all_dividends.index = total_dividend.index\n",
    "classified_all_dividends.sort_values(by=\"Dividend\", ascending=True)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:51.751141590Z",
     "start_time": "2023-12-25T01:57:51.634039081Z"
    }
   },
   "source": [
    "possible_classifications = len(classification_legend)\n",
    "classified_tickers = [[\"\"]] * possible_classifications\n",
    "\n",
    "for i in range(possible_classifications):\n",
    "    filtered_df = classified_all_dividends[classified_all_dividends[\"Classification\"] == i]\n",
    "    classified_tickers[i] = filtered_df.index.to_list()\n",
    "\n",
    "classified_tickers"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Definir um CAP (Carrying capacity) médio em cada categoria de empresa pagadora de dividendos"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "source": [
    "cap_per_cluster = {\n",
    "    classification: 0.0\n",
    "    for classification in range(possible_classifications)\n",
    "}\n",
    "\n",
    "all_dividends.index = pd.to_datetime(all_dividends.index, utc=True)\n",
    "all_dividends_by_year = all_dividends.groupby(by=pd.Grouper(freq=\"Y\")).sum()\n",
    "\n",
    "for classification, cluster in enumerate(classified_tickers):\n",
    "    cluster_mean_cap = []\n",
    "\n",
    "    for ticker in cluster:\n",
    "        ticker_dividend_history_df = all_dividends_by_year[ticker]\n",
    "\n",
    "        ticker_dividend_history_df = ticker_dividend_history_df.pct_change()\n",
    "        ticker_dividend_history_df = ticker_dividend_history_df.replace([np.inf, -np.inf], pd.NaT).dropna()\n",
    "        median_dividend = ticker_dividend_history_df.median()\n",
    "        cluster_mean_cap.append(median_dividend)\n",
    "\n",
    "    cap_per_cluster[classification] = np.mean(cluster_mean_cap)\n",
    "\n",
    "cap_per_cluster"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:52.047678170Z",
     "start_time": "2023-12-25T01:57:51.676240256Z"
    }
   },
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Treinamento do modelo para cada classificação de dividendos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:52.427027808Z",
     "start_time": "2023-12-25T01:57:51.856389244Z"
    }
   },
   "source": [
    "from prophet import Prophet\n",
    "\n",
    "ts_models = []\n",
    "\n",
    "for i, _ in enumerate(classification_legend):\n",
    "    df = all_dividends[classified_tickers[i]].mean(axis=1).to_frame()\n",
    "    df.reset_index(inplace=True)\n",
    "    df.rename(columns={\"Date\": \"ds\", 0: \"y\"}, inplace=True)\n",
    "    df[\"ds\"] = pd.to_datetime(df[\"ds\"], utc=True).dt.tz_convert(None)\n",
    "    df[\"cap\"] = cap_per_cluster[i]\n",
    "\n",
    "    model = Prophet()\n",
    "    model.fit(df)\n",
    "    ts_models.append(model)"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Previsão de dividendos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:53.480581519Z",
     "start_time": "2023-12-25T01:57:52.368097485Z"
    }
   },
   "source": [
    "for model in ts_models:\n",
    "    future = model.make_future_dataframe(periods=12 * 5, freq=\"MS\")\n",
    "    forecast = model.predict(future)\n",
    "    model.plot(forecast)"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Previsão de dividendos para o próximo ano da EGIE3.SA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "source": [
    "ticker = \"VALE3.SA\""
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:53.490910491Z",
     "start_time": "2023-12-25T01:57:53.409425617Z"
    }
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:53.604829929Z",
     "start_time": "2023-12-25T01:57:53.409585877Z"
    }
   },
   "source": [
    "dividends_df = all_dividends[ticker].to_frame()\n",
    "dividends_df"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:53.724001817Z",
     "start_time": "2023-12-25T01:57:53.534105544Z"
    }
   },
   "source": [
    "total_dividend = dividends_df[ticker].to_numpy().sum()\n",
    "\n",
    "payer_classification = cluster_model.predict(scaller.transform(total_dividend.reshape(-1, 1)))[0]\n",
    "payer_classification"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:53.743346265Z",
     "start_time": "2023-12-25T01:57:53.650814958Z"
    }
   },
   "source": [
    "dividends_df.reset_index(inplace=True)\n",
    "dividends_df.rename(columns={\"Date\": \"ds\", \"EGIE3.SA\": \"y\"}, inplace=True)\n",
    "dividends_df[\"ds\"] = pd.to_datetime(dividends_df[\"ds\"], utc=True).dt.tz_convert(None)\n",
    "dividends_df"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:54.025384939Z",
     "start_time": "2023-12-25T01:57:53.715749347Z"
    }
   },
   "source": [
    "model = ts_models[payer_classification]\n",
    "\n",
    "future = model.make_future_dataframe(periods=12, freq=\"M\")\n",
    "forecast = model.predict(future)"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:54.071585561Z",
     "start_time": "2023-12-25T01:57:53.927127395Z"
    }
   },
   "source": [
    "# Substituir os dividendos com valores negativos por 0\n",
    "forecast.loc[forecast[\"yhat\"] < 0, \"yhat\"] = 0\n",
    "forecast = forecast[[\"ds\", \"yhat\"]]\n",
    "forecast"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:54.265352832Z",
     "start_time": "2023-12-25T01:57:53.971678293Z"
    }
   },
   "source": [
    "forecast.rename(columns={\"ds\": \"Date\", \"yhat\": ticker}, inplace=True)\n",
    "forecast"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cálculo do valor intrínseco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:54.355960614Z",
     "start_time": "2023-12-25T01:57:54.081334970Z"
    }
   },
   "source": [
    "forecast_pcr_change = forecast.set_index(\"Date\")"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:57:54.651687230Z",
     "start_time": "2023-12-25T01:57:54.279076321Z"
    }
   },
   "source": [
    "forecast_pcr_change = forecast_pcr_change.groupby(by=pd.Grouper(freq=\"Y\")).sum()\n",
    "forecast_pcr_change = forecast_pcr_change.pct_change()\n",
    "forecast_pcr_change.dropna(inplace=True)\n",
    "forecast_pcr_change"
   ],
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "P = \\frac{D_1}{r - g}\n",
    "$$\n",
    "\n",
    "Onde,\n",
    "- P = Valor intrínseco da empresa;\n",
    "- D1 = Valor a ser pago em dividendos no próximo ano;\n",
    "- r = Custo constante de capital próprio para a empresa (ou taxa de retorno). Nesse caso usaremos o [ROIC](https://statusinvest.com.br/termos/r/roic) como indicador, porém é possível utilizar outras métricas como por exemplo o WACC;\n",
    "- g = Taxa constante de crescimento dos dividendos. Nesse modelo utilizamos a mediana do valor pago anualmente de dividendos até o ano atual e 1 ano no futuro (preditivo).\n",
    "    \n",
    "> Vale resaltar que as empresas classificados como \"Dividendos Baixo\" não são contempladas pelo modelo, pois podem ser empresas small caps ou apenas não pagam dividendos. Dessa forma, as empresas classificadas como \"Dividendos Moderado\" é utilizado o $r$ como o ROIC atual, já aqueles rotulados como \"Dividendos Alto\", o valor $r$ é o ROIC médio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "source": [
    "from selenium.webdriver.support import expected_conditions as EC\n",
    "from selenium import webdriver\n",
    "import time\n",
    "\n",
    "driver = webdriver.Chrome()\n",
    "driver.get(f\"https://statusinvest.com.br/acoes/{ticker.replace('.SA', '')}\")\n",
    "\n",
    "roic_button = WebDriverWait(driver, 5).until(\n",
    "    EC.presence_of_element_located(\n",
    "        (By.XPATH, r'//*[@id=\"indicators-section\"]/div[2]/div/div[4]/div/div[3]/div/div/div/button'))\n",
    ")\n",
    "time.sleep(2)\n",
    "roic_button.click()\n",
    "\n",
    "average_roic_element = WebDriverWait(driver, 5).until(\n",
    "    EC.presence_of_element_located((By.XPATH, r'//*[@id=\"main-modal\"]/div[2]/div[1]/div/div[1]/div/div[1]/strong'))\n",
    ")\n",
    "average_roic = average_roic_element.text\n",
    "\n",
    "currant_roic_element = WebDriverWait(driver, 5).until(\n",
    "    EC.presence_of_element_located((By.XPATH, r'//*[@id=\"main-modal\"]/div[2]/div[1]/div/div[1]/div/div[2]/strong'))\n",
    ")\n",
    "currant_roic = currant_roic_element.text\n",
    "\n",
    "exit_roic_menu_button = WebDriverWait(driver, 5).until(\n",
    "    EC.presence_of_element_located((By.XPATH, r'//*[@id=\"main-modal\"]/div[1]/button'))\n",
    ")\n",
    "time.sleep(2)\n",
    "exit_roic_menu_button.click()\n",
    "\n",
    "ev_element = WebDriverWait(driver, 5).until(\n",
    "    EC.presence_of_element_located((By.XPATH, r'/html/body/main/div[5]/div[1]/div/div[2]/div[8]/div/div/strong'))\n",
    ")\n",
    "ev = ev_element.text\n",
    "\n",
    "number_of_shares_element = WebDriverWait(driver, 5).until(\n",
    "    EC.presence_of_element_located((By.XPATH, r'/html/body/main/div[5]/div[1]/div/div[2]/div[9]/div/div/strong'))\n",
    ")\n",
    "number_of_shares = number_of_shares_element.text\n",
    "\n",
    "driver.quit()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-12-25T01:58:10.104414846Z",
     "start_time": "2023-12-25T01:57:54.386180727Z"
    }
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "source": [
    "def parse(raw: str) -> float:\n",
    "    return float(raw.split()[0].replace(\".\", \"\").replace(\",\", \".\").replace(\"%\", \"\"))\n",
    "\n",
    "\n",
    "def get_classification_legend(classified_all_dividends_: pd.DataFrame):\n",
    "    labels = [\"Baixo\", \"Moderado\", \"Alto\"]\n",
    "\n",
    "    uniques = classified_all_dividends_[\"Classification\"].unique().tolist()\n",
    "    dividends = {}\n",
    "\n",
    "    for classification_unique in uniques:\n",
    "        dividend = classified_all_dividends_[classified_all_dividends_[\"Classification\"] == classification_unique].iloc[0, 0]\n",
    "        dividends.update({classification_unique: dividend})\n",
    "    dividends = {key: value for key, value in sorted(dividends.items(), key=lambda item: item[1])}\n",
    "\n",
    "    return {classification: labels[i] for i, classification in enumerate(dividends.keys())}\n",
    "\n",
    "\n",
    "def get_classification_label_for(ticker: str, classified_all_dividends_: pd.DataFrame):\n",
    "    legend = get_classification_legend(classified_all_dividends_)\n",
    "    classification = classified_all_dividends_[classified_all_dividends_.index == ticker].iloc[0, -1]\n",
    "    \n",
    "    return legend[classification]\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-12-25T01:58:10.160491806Z",
     "start_time": "2023-12-25T01:58:10.126058214Z"
    }
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T01:58:10.291873735Z",
     "start_time": "2023-12-25T01:58:10.126192665Z"
    }
   },
   "source": [
    "roic = parse(currant_roic) if get_classification_label_for(ticker, classified_all_dividends) == \"Moderado\" else parse(average_roic)\n",
    "roic"
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-25T02:01:12.961110287Z",
     "start_time": "2023-12-25T02:01:12.828668827Z"
    }
   },
   "source": [
    "def calculate_intrinsic_value():\n",
    "    vi_current_roic = forecast.iloc[-12:, 1].sum() / (parse(currant_roic) / 100 - np.median(forecast_pcr_change))\n",
    "    vi_average_roic = forecast.iloc[-12:, 1].sum() / (parse(average_roic) / 100 - np.median(forecast_pcr_change))\n",
    "    vi_reference = parse(ev) / parse(number_of_shares)\n",
    "    \n",
    "    if round(vi_current_roic, 0) == round(vi_average_roic, 0):\n",
    "        if vi_reference * 0.8 <= vi_current_roic <= vi_reference * 1.2:\n",
    "            return vi_current_roic\n",
    "        else:\n",
    "            return 0\n",
    "    \n",
    "    if abs(vi_reference - vi_current_roic) > abs(vi_reference - vi_average_roic) and vi_reference * 0.8 <= vi_average_roic <= vi_reference * 1.2:\n",
    "        return vi_average_roic\n",
    "    elif 0.8 <= vi_current_roic <= vi_reference * 1.2:\n",
    "        return vi_current_roic\n",
    "    else:\n",
    "        return 0\n",
    "        "
   ],
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "source": [
    "calculate_intrinsic_value()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-12-25T02:01:13.484106447Z",
     "start_time": "2023-12-25T02:01:13.479553814Z"
    }
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [],
   "metadata": {
    "collapsed": false
   },
   "outputs": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}