Source code for policy_modules.employer_penalty

#!/usr/bin/env python

#needed to correctly run unit tests
import numpy as np
import pandas as pd
from utility_modules.get_parameters import get_params
from utility_modules.get_parameters import get_parse_params
import pdb

class EmployerPenalty():
    def __init__(self, policy_dict):

        #read in fpl data
        self.penalty_table =  get_params(policy_dict['employer_penalty'])
        self.firm_parameters = get_params(policy_dict['firm_behavior'])
        self.firm_nfte_pnlty = get_params(policy_dict['firm_nfte_pnlty'])

        # define first year of penalty
        self.penalty_year_start = min(self.penalty_table[self.penalty_table.min_fte <= 0].year)

    def set_year(self, curr_year):
        """
        return slice of pertinant year
        allows this to be reset at begining of each simulation year
        """

        if curr_year not in self.penalty_table.year.values:
            raise ValueError("penalty sheet does  not contain information on year under simulation")
        else:
            # collect parameters
            self.min_first_workers = self.penalty_table[self.penalty_table.year == curr_year].min_fte.item()
            self.min_firm_size = self.firm_nfte_pnlty[self.firm_nfte_pnlty.year == curr_year].min_firm_size.item()
            self.amt_pp = self.firm_nfte_pnlty[self.firm_nfte_pnlty.year == curr_year].amt_pp.item()
            self.subsidy_pp = self.firm_nfte_pnlty[self.firm_nfte_pnlty.year == curr_year].subsidy_pp.item()
            self.nfte_exempt = self.firm_nfte_pnlty[self.firm_nfte_pnlty.year == curr_year].nfte_exempt.item()
            self.curr_year = curr_year

    def set_firm(self, firm_id, worker_table):

        f_wrks = worker_table[worker_table.firm_id == firm_id]
        if f_wrks.shape[0] == 0:
            return 0
        else:
            #f_wrks = pd.merge(f_wrks, worker_table.Hieu[["person_id", "in_firm_weight"]], on = "person_id", how = "left")
            self.firm_size = (f_wrks.in_firm_weight * f_wrks.full_time).sum() # number of full-time workers

    def penalty(self, esi_offer, workers_on_xc=0, fplty_mult = 1):

        # "Large employers not offering coverage with at least one employee receiving susidies in the exchange..."
        if (not esi_offer) and (self.curr_year > self.penalty_year_start) and (self.firm_size >= self.min_firm_size) and workers_on_xc > 0:
            return self.amt_pp * fplty_mult* max(self.firm_size - self.min_first_workers, 0)
        # "Large employers offering coverage with at least one employee receiving subsidies in the exchange pay the lesser of..."
        elif (esi_offer) and (self.curr_year > self.penalty_year_start) and (self.firm_size >= self.min_firm_size) and workers_on_xc > 0:
            penalty_possibility_one = self.subsidy_pp * workers_on_xc
            penalty_possibility_two = self.amt_pp * fplty_mult* max(self.firm_size - self.min_first_workers, 0)
            return min(penalty_possibility_one, penalty_possibility_two)
        else:
            return 0