calculate_last_years_stats.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd"
      ],
      "outputs": [],
      "execution_count": 1,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "N_H=9\n",
        "hit = pd.read_csv('/Users/jgdwyer/Dropbox/fun/jabo2019/baseball-H2H-AuctionValues/source_data/2018_team_totals_hitters.csv', index_col=0)\n",
        "import scipy\n",
        "from scipy import stats\n",
        "from sklearn.linear_model import LinearRegression, Lasso\n",
        "hit_sgp = pd.DataFrame(columns=hit.columns, index=['slope','intercept'])\n",
        "for col in hit.columns: \n",
        "    if col == 'ERA' or col == 'WHIP':\n",
        "        ascending=False\n",
        "    else:\n",
        "        ascending=True\n",
        "    slope, intercept, r_value, p_value, std_err = (\n",
        "        scipy.stats.linregress(range(1, 15),hit[col].sort_values(ascending=ascending).reset_index(drop=True)))\n",
        "    \n",
        "    hit_sgp.loc['slope', col] = slope\n",
        "    hit_sgp.loc['intercept', col] = intercept"
      ],
      "outputs": [],
      "execution_count": 47,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "outputs": [],
      "execution_count": 48,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "col='SB'\n",
        "if col == 'ERA' or col == 'WHIP':\n",
        "    ascending=False\n",
        "else:\n",
        "    ascending=True\n",
        "plt.plot(np.arange(1, 15), hit[col].sort_values(ascending=ascending).reset_index(drop=True) ,marker='o', ls='')\n",
        "plt.plot(np.arange(1,15), hit_sgp.loc['intercept', col] + np.arange(1,15)*hit_sgp.loc['slope', col])\n",
        "# hit_sgp"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 50,
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x10fadd410>]"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<matplotlib.figure.Figure at 0x10f92c1d0>"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 50,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "hit_sgp"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 51,
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>BA</th>\n",
              "      <th>OBP</th>\n",
              "      <th>R</th>\n",
              "      <th>SB</th>\n",
              "      <th>RBI</th>\n",
              "      <th>HR</th>\n",
              "      <th>TB</th>\n",
              "      <th>SLG</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>slope</th>\n",
              "      <td>0.00272747</td>\n",
              "      <td>0.0029011</td>\n",
              "      <td>15.1437</td>\n",
              "      <td>5.28967</td>\n",
              "      <td>15.8182</td>\n",
              "      <td>5.43473</td>\n",
              "      <td>48.2598</td>\n",
              "      <td>0.00375385</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>intercept</th>\n",
              "      <td>0.241044</td>\n",
              "      <td>0.314385</td>\n",
              "      <td>604.722</td>\n",
              "      <td>43.7703</td>\n",
              "      <td>576.642</td>\n",
              "      <td>165.254</td>\n",
              "      <td>1883.15</td>\n",
              "      <td>0.420275</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                   BA        OBP        R       SB      RBI       HR       TB  \\\n",
              "slope      0.00272747  0.0029011  15.1437  5.28967  15.8182  5.43473  48.2598   \n",
              "intercept    0.241044   0.314385  604.722  43.7703  576.642  165.254  1883.15   \n",
              "\n",
              "                  SLG  \n",
              "slope      0.00375385  \n",
              "intercept    0.420275  "
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 51,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "!ls"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LICENSE.txt      Untitled1.ipynb  df.csv           \u001b[1m\u001b[34msource_data\u001b[m\u001b[m\r\n",
            "README.md        \u001b[1m\u001b[34mbaseball\u001b[m\u001b[m         \u001b[1m\u001b[34moutput\u001b[m\u001b[m\r\n",
            "Untitled.ipynb   cat.p            requirements.txt\r\n"
          ]
        }
      ],
      "execution_count": 46,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hit_sgp.to_csv('./source_data/sgp_thresh_lastyear_values_H.csv', index=False)"
      ],
      "outputs": [],
      "execution_count": 45,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "sort_key = pd.Series(pos_offsets).sort_values()\n",
        "sorted(['2B', 'U'], key=lambda x: sort_key[x])[0]"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 85,
          "data": {
            "text/plain": [
              "'2B'"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 85,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "pos_offsets = {'C': -6.495901095455834, 'SS': 0.4498213372240938, '2B': 0.3713500858289853, '3B': 2.3245547497915267, 'CF': 2.1983041054264563, 'LF': 1.302715110948761, 'RF': 1.920148110166175, '1B': 2.2798699732252903, 'U': 2.060807822722109}\n",
        "sgp_pos_add_sort = sorted(pos_offsets.items(), key=lambda pos_offsets: pos_offsets[1], reverse=True) # largest to smallest\n",
        "sgp_pos_add_sort"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 72,
          "data": {
            "text/plain": [
              "[('3B', 2.3245547497915267),\n",
              " ('1B', 2.2798699732252903),\n",
              " ('CF', 2.1983041054264563),\n",
              " ('U', 2.060807822722109),\n",
              " ('RF', 1.920148110166175),\n",
              " ('LF', 1.302715110948761),\n",
              " ('SS', 0.4498213372240938),\n",
              " ('2B', 0.3713500858289853),\n",
              " ('C', -6.495901095455834)]"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 72,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "a=pd.Series(index=['U', 'Uonly', '1B', 'RF', 'LF', 'CF', '3B', '2B', 'SS', 'C'])"
      ],
      "outputs": [],
      "execution_count": 39,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "a['3B'] = 1\n",
        "a['U'] = 0\n",
        "a['2B'] = 0\n",
        "a['SS']= 0"
      ],
      "outputs": [],
      "execution_count": 53,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "b=list(a[a==a.min()].index)\n",
        "print(b)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['U', '2B', 'SS']\n"
          ]
        }
      ],
      "execution_count": 57,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "['U', 'Uonly', '1B', 'RF', 'LF', 'CF', '3B', '2B', 'SS', 'C']\n",
        "sort_order = {'C': 0, 'SS': 1, '2B': 2, '3B': 3, 'CF': 4, 'LF': 5, 'RF': 6, '1B': 7, 'Uonly': 8, 'U': 9}\n",
        "# b.sort(key=lambda x: sort_order[x])\n",
        "c=sorted(b, key=lambda x: sort_order[x])[0]\n",
        "print(c)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SS\n"
          ]
        }
      ],
      "execution_count": 58,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "hit = pd.read_csv('/Users/jgdwyer/Dropbox/fun/jabo2018/source_data/2017_team_totals_hitters.csv', index_col=0)\n",
        "%matplotlib inline\n",
        "# hit['HR'].hist()\n",
        "hit.hist()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 20,
          "data": {
            "text/plain": [
              "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x113015da0>,\n",
              "        <matplotlib.axes._subplots.AxesSubplot object at 0x11368a6a0>,\n",
              "        <matplotlib.axes._subplots.AxesSubplot object at 0x11363df60>],\n",
              "       [<matplotlib.axes._subplots.AxesSubplot object at 0x1137474a8>,\n",
              "        <matplotlib.axes._subplots.AxesSubplot object at 0x1136ec3c8>,\n",
              "        <matplotlib.axes._subplots.AxesSubplot object at 0x1136ec5f8>],\n",
              "       [<matplotlib.axes._subplots.AxesSubplot object at 0x113860780>,\n",
              "        <matplotlib.axes._subplots.AxesSubplot object at 0x1138d3eb8>,\n",
              "        <matplotlib.axes._subplots.AxesSubplot object at 0x11393c198>]],\n",
              "      dtype=object)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<matplotlib.figure.Figure at 0x112fcf630>"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 20,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "df= pd.read_csv('df.csv', index_col=0)"
      ],
      "outputs": [],
      "execution_count": 94,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "cat_offsets=pd.read_pickle('./cat.p')"
      ],
      "outputs": [],
      "execution_count": 97,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "out2 = calcSGPHitters(out, cat_offsets)"
      ],
      "outputs": [],
      "execution_count": 160,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "cat_offsets, pos_offsets, star_thresh = calcPositionOffsets(cat_offsets, out)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                Name          Team    G   PA   AB    H  2B  3B  HR    R  \\\n",
            "0         Mike Trout        Angels  155  651  524  162  32   3  39  114   \n",
            "1  Giancarlo Stanton       Yankees  150  630  541  155  25   1  57  111   \n",
            "2       Bryce Harper     Nationals  147  616  505  152  30   1  37  100   \n",
            "3      Nolan Arenado       Rockies  158  665  596  176  38   5  40  101   \n",
            "4   Paul Goldschmidt  Diamondbacks  157  658  543  158  33   3  32   99   \n",
            "\n",
            "     ...          wSLG      sAVG      sOBP      sSLG       sHR        sR  \\\n",
            "0    ...      0.016778  3.412995  6.111302  3.528794  2.570014  3.351517   \n",
            "1    ...      0.022839  1.785050  2.749289  4.684093  4.999459  3.118869   \n",
            "2    ...      0.013994  2.750869  4.934367  2.997909  2.300076  2.265825   \n",
            "3    ...      0.014874  2.592297  1.580612  3.165719  2.704983  2.343375   \n",
            "4    ...      0.009428  2.125324  4.456585  2.127488  1.625230  2.188276   \n",
            "\n",
            "       sRBI      sSB       sTB        SGP  \n",
            "0  2.339009  2.47920  2.283610  26.076441  \n",
            "1  3.948916 -0.02226  3.185030  24.448447  \n",
            "2  1.967492  0.95053  1.732742  19.899811  \n",
            "3  2.834365  0.11671  2.959675  18.297737  \n",
            "4  1.719814  1.78435  1.682663  17.709731  \n",
            "\n",
            "[5 rows x 47 columns]\n"
          ]
        }
      ],
      "execution_count": 158,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "out2['SGP'][:14*9].sum()/91/8"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 153,
          "data": {
            "text/plain": [
              "1.0757106929660114"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 153,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "cat_offsets"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 159,
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>sAVG</th>\n",
              "      <th>sHR</th>\n",
              "      <th>sOBP</th>\n",
              "      <th>sR</th>\n",
              "      <th>sRBI</th>\n",
              "      <th>sSB</th>\n",
              "      <th>sSLG</th>\n",
              "      <th>sTB</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>-0.308248</td>\n",
              "      <td>0.487982</td>\n",
              "      <td>-1.033137</td>\n",
              "      <td>-0.966252</td>\n",
              "      <td>-0.353746</td>\n",
              "      <td>-0.719854</td>\n",
              "      <td>-0.33016</td>\n",
              "      <td>-1.065191</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       sAVG       sHR      sOBP        sR      sRBI       sSB     sSLG  \\\n",
              "0 -0.308248  0.487982 -1.033137 -0.966252 -0.353746 -0.719854 -0.33016   \n",
              "\n",
              "        sTB  \n",
              "0 -1.065191  "
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 159,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "star_thresh"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 151,
          "data": {
            "text/plain": [
              "{'sAVG': -1.4210854715202004e-14,\n",
              " 'sHR': 1.4210854715202004e-14,\n",
              " 'sOBP': 1.4210854715202004e-14,\n",
              " 'sR': -4.263256414560601e-14,\n",
              " 'sRBI': -2.842170943040401e-14,\n",
              " 'sSB': 0.0,\n",
              " 'sSLG': 0.0,\n",
              " 'sTB': -2.842170943040401e-14}"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 151,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "pos_offsets"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 133,
          "data": {
            "text/plain": [
              "{'1B': 2.0564904318475583,\n",
              " '2B': -0.0210954341750913,\n",
              " '3B': 1.163812060411236,\n",
              " 'C': -6.073956854147543,\n",
              " 'CF': 1.723150516397716,\n",
              " 'LF': 1.6508726034466132,\n",
              " 'RF': 1.6934956078129948,\n",
              " 'SS': 0.036244637844293104,\n",
              " 'U': 1.5351473423015418}"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 133,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "N_teams = 14\n",
        "N_activehitters = 9\n",
        "N_SP = 8\n",
        "N_RP = 4\n",
        "budget = 260\n",
        "frac_hitter_budget = 0.5\n",
        "frac_pitcher_budget = 1 - frac_hitter_budget\n",
        "\n",
        "def load_sgp_thresh_last_year(players):\n",
        "    \"\"\"Get the SGP replacement level headers from the matlab script\n",
        "    (Get_SGP_thresholds_from_lastyeardata.m)\"\"\"\n",
        "    return pd.read_csv('./source_data/sgp_thresh_lastyear_values_' + players + '.csv')\n",
        "\n",
        "def calcSGPHitters(df, cat_offsets):\n",
        "    \"\"\"Calculates SGP values for hitters\"\"\"\n",
        "    # Get the SGP replacement level headers from the matlab script (Get_SGP_thresholds_from_lastyeardata.m)\n",
        "    sgp = load_sgp_thresh_last_year('H')\n",
        "    # Sort the data\n",
        "    df = df.sort_values(by='wOBA', ascending=False)\n",
        "    # Keep only the top players for calculating averages for rate categories\n",
        "    top_hitters = df.head(N_activehitters * N_teams)\n",
        "    # Calculate \"wAVG\"\n",
        "    numer = (N_activehitters - 1) * top_hitters['H'].mean() + df['H']\n",
        "    denom = (N_activehitters - 1) * top_hitters['AB'].mean() + df['AB']\n",
        "    df['wAVG'] = numer/denom - top_hitters['AVG'].mean()\n",
        "    # Calculate wOBA\n",
        "    monbase = top_hitters['PA'].mean() * top_hitters['OBP'].mean()\n",
        "    numer = (N_activehitters - 1) * monbase + df['H'] + df['BB'] + df['HBP']\n",
        "    denom = (N_activehitters - 1) * top_hitters['PA'].mean() + df['PA']\n",
        "    df['wOBP'] = numer/denom - top_hitters['OBP'].mean()\n",
        "    # Calculate wSLG\n",
        "    numer = (N_activehitters - 1) * top_hitters['TB'].mean() + df['TB']\n",
        "    denom = (N_activehitters - 1) * top_hitters['AB'].mean() + df['AB']\n",
        "    df['wSLG'] = numer/denom - top_hitters['SLG'].mean()\n",
        "    # Now get the sgp by dividing by the values calculated from last year's totals\n",
        "    for cat in ['AVG', 'OBP', 'SLG']:\n",
        "        df['s' + cat] = df['w' + cat] / sgp[cat][0] - cat_offsets['s' + cat][0]\n",
        "    for cat in ['HR', 'R', 'RBI', 'SB', 'TB']:\n",
        "        df['s' + cat] = (df[cat] - sgp[cat][1]) / sgp[cat][0] - cat_offsets['s' + cat][0]\n",
        "    # Sum up all of these entries to get the total SGP\n",
        "    df['SGP'] = df[['sAVG', 'sOBP', 'sSLG', 'sHR',\n",
        "                    'sR', 'sRBI', 'sSB', 'sTB']].sum(axis=1)\n",
        "    # Now sort by total SGP descending\n",
        "    df = df.sort_values(by='SGP', ascending=False)\n",
        "    return df.reset_index(drop=True)"
      ],
      "outputs": [],
      "execution_count": 99,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def calcPositionOffsets(cat_offsets, df):\n",
        "    \"\"\"Calculate the position offset values.\n",
        "    Go through all hitters in order of SGP and assign them positions. It doesn't\n",
        "    actually matter what list a player is assigned to. The point is to get\n",
        "    replacement values\"\"\"\n",
        "    # Initiailize each list by putting in the best hitter (will remove later)\n",
        "    meta_ranked = [m: pd.DataFrame(columns=df.columns) for m in ['U', 'Uonly', '1B', 'RF', 'LF', 'CF', '3B', '2B', 'SS', 'C']]\n",
        "    #     meta_ranked = dict()\n",
        "#     for m in ['U', 'Uonly', '1B', 'RF', 'LF', 'CF', '3B', '2B', 'SS', 'C']:\n",
        "#         meta_ranked[m] = df.head(1)\n",
        "    print(df.head())\n",
        "    for _, row in df.iterrows():\n",
        "        # Get the sgp of the player in this row\n",
        "        sgp = row['SGP']\n",
        "        # now get the rank of the available positions\n",
        "        posrank = dict()\n",
        "        # Loop over all positions this player is eligible at\n",
        "        # Get the SGP of all players at each eligible position\n",
        "        for pos in row['position'].split(','):\n",
        "            sgpofcolumn = meta_ranked[pos]['SGP'].get_values()\n",
        "            # For each eligible position, find out how many players are better (by SGP)\n",
        "            posrank[pos] = get_rank(sgpofcolumn, sgp)\n",
        "        # Get which position the player would be the next best at by finding the\n",
        "        # one with the least number of better players at it\n",
        "        highest = min(posrank.values())\n",
        "        bestposits = [k for k, v in posrank.items() if v == highest]\n",
        "        # In the case of ties, go down the defensive spectrum\n",
        "        # Values overwrite each other so the toughest to fill position is left at the end\n",
        "        for pp in ['U', 'Uonly', '1B', 'RF', 'LF', 'CF', '3B', '2B', 'SS', 'C']:\n",
        "            if pp in bestposits:\n",
        "                bestpos = pp\n",
        "        # Finally add the row to the end of the correct dataframe\n",
        "        meta_ranked[bestpos] = meta_ranked[bestpos].append(row, ignore_index='True')\n",
        "    # Now remove the initialized value of the best hitter in each list\n",
        "#     for m in meta_ranked:\n",
        "#         meta_ranked[m] = meta_ranked[m].drop(0)\n",
        "#         meta_ranked[m] = meta_ranked[m].reset_index(drop=True)\n",
        "    sgp = load_sgp_thresh_last_year('H')\n",
        "    # also need to account for the bench hitters. assume every team carries 3.\n",
        "    # then 42 extra hitters. more than 4 teams worth\n",
        "    star_thresh = dict()\n",
        "    # We need to normalize SGP so that the total available SGP of all hitters is\n",
        "    # the number of points that can be gained (i.e., for each category, there are\n",
        "    # 14 teams, so there are 13 points to be gained in each for each)\n",
        "    sgp_new = dict()\n",
        "    for sgpcat in ['sAVG', 'sOBP', 'sSLG', 'sHR', 'sR', 'sRBI', 'sSB', 'sTB']:\n",
        "        # loop over hitting categories\n",
        "        star = 0\n",
        "        for pos in ['U', '1B', 'RF', 'LF', 'CF', '3B', '2B', 'SS', 'C']:  # NO UONLY\n",
        "            #Load the sum of SGP for each category at each position\n",
        "            star += meta_ranked[pos][sgpcat][:N_teams].sum()\n",
        "        # We're aiming to minimize this total in order that the sum of points of\n",
        "        # all the owned players represents the correct\n",
        "        # Use sum(i=1:N,i)=(N+1)N/2\n",
        "        # Total SGP available: Team A can gain 13pnts, Team B can gain 12pnts, etc.\n",
        "        # total number of sgp that can be gained by all teams..each category should have the same # ofthese\n",
        "        # N_teams not N_teams+4\n",
        "        star_thresh[sgpcat] = star - N_teams*(N_teams-1)/2\n",
        "        # N_teams-1    #N_teams*(N_teams-1)/2\n",
        "        # This is the offset threshold that gets added on so that the total number of category points are right\n",
        "        # This gets added in to the old values\n",
        "        # Divide the difference by the total number of active players since all  will be contributing to the category\n",
        "        cat_offsets[sgpcat] += star_thresh[sgpcat] / (N_teams * N_activehitters)\n",
        "    # Get the positional difference by looking at the value of the last player\n",
        "    pos_offsets = dict()\n",
        "    for pos in ['U', '1B', 'RF', 'LF', 'CF', '3B', '2B','SS', 'C']:\n",
        "        # TODO: These don't seem to be normalized correctly\n",
        "        pos_offsets[pos] = meta_ranked[pos]['SGP'][N_teams-1]\n",
        "        # pos_offsets[pos] = meta_ranked[pos]['SGP'][:(N_teams-1)].mean()\n",
        "    return cat_offsets, pos_offsets, star_thresh\n",
        "\n\n",
        "def get_rank(listo, sgp):\n",
        "    \"\"\"returns the index of the first item in a sorted list (must be descending)\n",
        "     whose value is less than an input value\"\"\"\n",
        "    # Get the first item in the list whose value falls under the entered one\n",
        "    try:\n",
        "        index = next(index for index, value in enumerate(listo) if value < sgp)\n",
        "    # If we reach the end of the list use the last entry as the index\n",
        "    except StopIteration:\n",
        "        index = len(listo)\n",
        "    # If the largest value in the list is the first one below the input value,\n",
        "    # return an empty string. This is meant for the case in which the player\n",
        "    # is the best at their position and accounts for players being placed at\n",
        "    # U when they should really go to another list\n",
        "    if index == 0:\n",
        "        index = ''\n",
        "    return index"
      ],
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "invalid syntax (<ipython-input-155-adf398700246>, line 7)",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-155-adf398700246>\"\u001b[0;36m, line \u001b[0;32m7\u001b[0m\n\u001b[0;31m    meta_ranked = [m: pd.DataFrame(columns=df.columns) for m in ['U', 'Uonly', '1B', 'RF', 'LF', 'CF', '3B', '2B', 'SS', 'C']]\u001b[0m\n\u001b[0m                    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ],
      "execution_count": 155,
      "metadata": {}
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython2",
      "version": "2.7.14",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 2,
        "name": "ipython"
      }
    },
    "kernel_info": {
      "name": "python3"
    },
    "nteract": {
      "version": "0.12.3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}