ogeth 0.0.0__py3-none-any.whl

ogeth/labor.py

@@ -0,0 +1,198 @@
+"""
+------------------------------------------------------------------------
+Computes the average labor participation rate for each age cohort.
+------------------------------------------------------------------------
+"""
+
+import os
+import numpy as np
+import pandas as pd
+import scipy.ndimage.filters as filter
+from scipy import interpolate
+import matplotlib
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+
+CUR_DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+def get_labor_data(
+    year=2023, data_dir=os.path.join(CUR_DIR, "..", "ogeth", "data", "qlfs")
+):
+    """
+    Read in "raw" Quarterly Labour Force Survey data to calculate moments.
+
+    Args:
+        year (int): year of data to read in
+        data_dir (str): path to directory with QLFS data
+
+    Returns:
+        df (Pandas DataFrame): QLFS data to compute labor supply from
+
+    """
+    # read in data for all quarters
+    df_list = []
+    for q in range(1, 5):
+        file = os.path.join(data_dir, f"qlfs-{year}-q{q}-worker-v1.csv")
+        df = pd.read_csv(file, encoding="latin-1", low_memory=False)
+        df_list.append(df)
+    df = pd.concat(df_list)
+
+    # rename some variables
+    df.rename(
+        columns={
+            "Q418HRSWRK": "hours",
+            # "Q14AGE": "age",
+            "age_grp1": "age_group",
+            # "Hrswrk": "hours2",
+            "Weight": "weight",
+        },
+        inplace=True,
+    )
+    # if hours is a string, take only part after space
+    df["hours"] = df["hours"].str.split().str[-1]
+    df["hours"] = pd.to_numeric(df["hours"], errors="coerce")
+    # create weighted mean hours by age
+    # replace missing hours with zero
+    df["hours"] = df["hours"].fillna(0)
+    # drop if hours are missing
+    # df = df[~df['hours'].isna()]
+
+    return df
+
+
+def compute_labor_moments(df, S=80):
+    """
+    Compute moments from labor data.
+
+    Args:
+        df (Pandas DataFrame): QLFS data to compute labor supply from
+        S (int): number of periods of economic life for model households
+
+    Returns:
+        labor_dist_out (Numpy array): fraction of time spent working
+            by age
+
+    """
+
+    # Find fraction of total time people work on average by age group
+    by_age = pd.DataFrame(
+        df.groupby("age_group").apply(
+            lambda x: (x["hours"] * x["weight"]).sum() / x["weight"].sum()
+        )
+    )
+    # give column name to hours
+    by_age.columns = ["hours"]
+    # drop with indices that are in ['00-04', '05-09', '10-14', '14-Oct', '9-May']
+    by_age = by_age.drop(["00-04", "05-09", "10-14", "14-Oct", "9-May"])
+    # also drop age 15-19 since not in model
+    # by_age = by_age.drop('15-19')
+    # rename index for 75+ to 75-85 to be able to get midpoint
+    by_age = by_age.rename(index={"75+": "75-85"})
+    # compute midpoints of age groups
+    age_midpoints = (
+        pd.Series(by_age.index)
+        .str.split("-")
+        .apply(lambda x: (int(x[0]) + int(x[1])) / 2)
+    )
+
+    # get fraction of time endowment worked (assume time
+    # endowment is 24 hours minus required time to sleep)
+    by_age["frac_work"] = by_age["hours"] / ((24 - 8) * 7)
+
+    # fit a cubic spline to these data points -- only through age 57
+    # labor_dist = interpolate.interp1d(
+    #     age_midpoints[:-5], by_age['frac_work'][:-5], kind='cubic')
+    labor_dist = interpolate.interp1d(
+        age_midpoints, by_age["frac_work"], kind="cubic"
+    )
+    # now evaluate the spline at each age
+    labor_spline = labor_dist(np.linspace(20, 80, 60))
+
+    # Data have sufficient obs through age  57 (55-59 age group)
+    # Fit a line to the last few years of the average labor
+    # participation which extends from ages 57 to 100.
+    slope = (labor_spline[-1] - labor_spline[-8]) / (8 + 1)
+    # intercept = by_age['frac_work'][-1] - slope*len(by_age['frac_work'])
+    # extension = slope * (np.linspace(56, 80, 23)) + intercept
+    # to_dot = slope * (np.linspace(45, 56, 11)) + intercept
+
+    labor_dist_data = np.zeros(80)
+    labor_dist_data[:60] = labor_spline
+    labor_dist_data[60:] = labor_spline[-1] + slope * range(20)
+
+    # the above computes moments if the model period is a year
+    # the following adjusts those moments in case it is smaller
+    labor_dist_out = (
+        1  # filter.uniform_filter(labor_dist_data, size=int(80 / S))[
+    )
+    #     :: int(80 / S)
+    # ]
+
+    return labor_dist_data, age_midpoints, by_age, labor_dist_out
+
+
+def VCV_moments(qlfs, n=1000, S=80):
+    """
+    Compute Variance-Covariance matrix for labor moments by
+    bootstrapping data.
+
+    Args:
+        cps (Pandas DataFrame): CPS data to compute labor supply from
+        S (int): number of periods of economic life for model households
+        n (int): number of bootstrap iterations to run
+        bin_weights (Numpy array): ability weight, length J
+
+    Output:
+        VCV (Numpy array): = variance-covariance matrix of labor
+            moments, size SxS
+
+    """
+    labor_moments_boot = np.zeros((n, S))
+    for i in range(n):
+        boot = qlfs[np.random.randint(2, size=len(qlfs.index)).astype(bool)]
+        _, _, _, labor_moments_boot[i, :] = compute_labor_moments(boot, S)
+
+    VCV = np.cov(labor_moments_boot.T)
+
+    return VCV
+
+
+def labor_data_graphs(
+    year=2023,
+    data_dir=os.path.join(CUR_DIR, "..", "ogeth", "data", "qlfs"),
+    S=80,
+    output_dir=None,
+):
+    """
+    Plot labor supply data.
+
+    Args:
+        weighted (Numpy array):
+        S (int): number of periods of economic life for model households
+        J (int): number of lifetime income groups
+        output_dir (str): path to save figures to
+
+    Returns:
+        None
+
+    """
+    # get labor data
+    interpolated_data, age_midpoints, by_age, _ = compute_labor_moments(
+        get_labor_data(year, data_dir), S
+    )
+    plt.plot(np.linspace(20, 100, 80), interpolated_data)
+    # add scatter plot of raw data
+    plt.scatter(age_midpoints, by_age["frac_work"], color="red", alpha=0.5)
+    plt.xlabel("Age")
+    plt.ylabel("Labor supply")
+    plt.title("Labor supply by age")
+    plt.legend(["Interpolated", "Data"])
+    if output_dir:
+        plt.savefig(
+            os.path.join(output_dir, "labor_dist_data.png"),
+            bbox_inches="tight",
+            dpi=300,
+        )
+    else:
+        return plt

ogeth/macro_params.py

@@ -0,0 +1,294 @@
+"""
+This module uses data from World Bank WDI, World Bank Quarterly Public
+Sector Debt (QPSD) database, the IMF, and UN ILO to find values for
+parameters for the OG-ETH model that rely on macro data for calibration.
+"""
+
+# imports
+from pandas_datareader import wb
+import pandas as pd
+import numpy as np
+import requests
+import datetime
+import statsmodels.api as sm
+from io import StringIO
+
+
+def get_macro_params(
+    data_start_date=datetime.datetime(1947, 1, 1),
+    data_end_date=datetime.datetime(2024, 12, 31),
+    country_iso="ETH",
+    update_from_api=False,
+):
+    """
+    Compute values of parameters that are derived from macro data
+
+    Args:
+        data_start_date (datetime): start date for data
+        data_end_date (datetime): end date for data
+        country_iso (str): ISO code for country
+
+    Returns:
+        macro_parameters (dict): dictionary of parameter values
+    """
+    # initialize a dictionary of parameters
+    macro_parameters = {}
+    # baseline date formatted for World Bank data
+    baseline_YYYYQ = (
+        str(data_end_date.year)
+        + "Q"
+        + str(pd.Timestamp(data_end_date).quarter)
+    )
+
+    """
+    Retrieve data from the World Bank World Development Indicators.
+    """
+    # Dictionaries of variables and their corresponding World Bank codes
+    # Annual data
+    wb_a_variable_dict = {
+        "GDP per capita (constant 2015 US$)": "NY.GDP.PCAP.KD",
+        "Real GDP (constant 2015 US$)": "NY.GDP.MKTP.KD",
+        "Nominal GDP (current US$)": "NY.GDP.MKTP.CD",
+        "General government final consumption expenditure (current US$)": "NE.CON.GOVT.CD",
+    }
+    # Quarterly data
+    wb_q_variable_dict = {
+        "Gross PSD USD - domestic creditors": "DP.DOD.DECD.CR.PS.CD",
+        "Gross PSD USD - external creditors": "DP.DOD.DECX.CR.PS.CD",
+        "Gross PSD Gen Gov - percentage of GDP": "DP.DOD.DECT.CR.GG.Z1",
+    }
+    if update_from_api:
+        try:
+            # pull series of interest from the WB using pandas_datareader
+            # Annual data
+            wb_data_a = wb.download(
+                indicator=wb_a_variable_dict.values(),
+                country=country_iso,
+                start=data_start_date,
+                end=data_end_date,
+            )
+            wb_data_a.rename(
+                columns=dict((y, x) for x, y in wb_a_variable_dict.items()),
+                inplace=True,
+            )
+            # Quarterly data
+            wb_data_q = wb.download(
+                indicator=wb_q_variable_dict.values(),
+                country=country_iso,
+                start=data_start_date,
+                end=data_end_date,
+            )
+            wb_data_q.rename(
+                columns=dict((y, x) for x, y in wb_q_variable_dict.items()),
+                inplace=True,
+            )
+            # Remove the hierarchical index (country and year) of
+            # wb_data_q and create a single row index using year
+            wb_data_q = wb_data_q.reset_index()
+            wb_data_q = wb_data_q.set_index("year")
+
+            # Function to get the latest valid data if baseline_YYYYQ is missing or NaN
+            def get_valid_data(series, baseline_YYYYQ):
+                value = series.get(baseline_YYYYQ, None)
+
+                if pd.isna(value):
+                    latest_non_nan = series.dropna().last_valid_index()
+
+                    if latest_non_nan is not None:
+                        print(
+                            f"Warning: No data for {baseline_YYYYQ}. Using last available quarter: {latest_non_nan}"
+                        )
+                        value = series.get(latest_non_nan, None)
+                    else:
+                        print(
+                            "Warning: No historical data available. Skipping update."
+                        )
+                        value = None
+
+                return value
+
+            # Compute macro parameters from WB data
+            macro_parameters["initial_debt_ratio"] = get_valid_data(
+                pd.Series(wb_data_q["Gross PSD Gen Gov - percentage of GDP"])
+                / 100,
+                baseline_YYYYQ,
+            )
+            print(
+                f"initial_debt_ratio updated from World Bank API: {macro_parameters['initial_debt_ratio']}"
+            )
+
+            # Compute initial_foreign_debt_ratio safely
+            if (
+                "Gross PSD USD - external creditors" in wb_data_q.columns
+                and "Gross PSD USD - domestic creditors" in wb_data_q.columns
+            ):
+
+                total_debt = (
+                    wb_data_q["Gross PSD USD - domestic creditors"]
+                    + wb_data_q["Gross PSD USD - external creditors"]
+                )
+
+                # Avoid division by zero
+                wb_data_q["foreign_debt_ratio"] = wb_data_q[
+                    "Gross PSD USD - external creditors"
+                ] / total_debt.replace(0, np.nan)
+
+                macro_parameters["initial_foreign_debt_ratio"] = (
+                    get_valid_data(
+                        wb_data_q["foreign_debt_ratio"], baseline_YYYYQ
+                    )
+                )
+            else:
+                print(
+                    "Warning: Missing debt variables in World Bank data. Skipping update for initial_foreign_debt_ratio."
+                )
+
+            print(
+                f"initial_foreign_debt_ratio updated from World Bank API: {macro_parameters['initial_foreign_debt_ratio']}"
+            )
+
+            # Compute zeta_D safely
+            macro_parameters["zeta_D"] = [
+                macro_parameters["initial_foreign_debt_ratio"]
+            ]  # Since it's the same formula, we use the same calculated value
+
+            print(
+                f"zeta_D updated from World Bank API: {macro_parameters['zeta_D']}"
+            )
+
+            # Compute annual GDP growth safely
+            if "GDP per capita (constant 2015 US$)" in wb_data_a.columns:
+                g_y_series = wb_data_a[
+                    "GDP per capita (constant 2015 US$)"
+                ].pct_change(-1)
+
+                # If all values are NaN, return None
+                macro_parameters["g_y_annual"] = (
+                    g_y_series.mean() if not g_y_series.isna().all() else None
+                )
+            else:
+                print(
+                    "Warning: Missing GDP per capita data in World Bank data. Skipping update for g_y_annual."
+                )
+
+            print(
+                f"g_y_annual updated from World Bank API: {macro_parameters['g_y_annual']}"
+            )
+        except:
+            print("Failed to retrieve data from World Bank")
+            print("Will not update the following parameters:")
+            print(
+                "[initial_debt_ratio, initial_foreign_debt_ratio, zeta_D, g_y]"
+            )
+    else:
+        print("Not updating from World Bank API")
+
+    """
+    Retrieve labour share data from the United Nations ILOSTAT Data API
+    (see https://rshiny.ilo.org/dataexplorer9/?lang=en)
+    The series code is SDG_1041_NOC_RT_A (capital share)
+    Labor share (gamma) = 1 - capital share
+    If this fails we will not update gamma in 'default_parameters.json'
+    """
+    if update_from_api:
+        try:
+            target = (
+                "https://rplumber.ilo.org/data/indicator/"
+                + "?id=SDG_1041_NOC_RT_A"
+                + "&ref_area="
+                + str(country_iso)
+                + "&timefrom="
+                + str(data_start_date.year)
+                + "&timeto="
+                + str(data_end_date.year)
+                + "&type=both&format=.csv"
+            )
+            # Add headers
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+            }
+
+            print("Attempting to update gamma from ILOSTAT")
+            response = requests.get(target, headers=headers)
+            if response.status_code != 200:
+                print(f"Error: Received status code {response.status_code}")
+            else:
+                print("Request successful.")
+            csv_content = StringIO(response.text)
+            df_temp = pd.read_csv(csv_content)
+            ilo_data = df_temp[["time", "obs_value"]]
+            # find gamma, capital's share of income
+            macro_parameters["gamma"] = [
+                1
+                - (
+                    (
+                        ilo_data.loc[
+                            ilo_data["time"] == data_end_date.year, "obs_value"
+                        ].squeeze()
+                    )
+                    / 100
+                )
+            ]
+            print(
+                f"gamma updated from ILOSTAT API: {macro_parameters['gamma']}"
+            )
+        except:
+            print("Failed to retrieve data from ILOSTAT")
+            print("Will not update gamma")
+    else:
+        print("Not updating from ILOSTAT API")
+
+    """
+    Calibrate parameters from IMF data
+    """
+
+    if update_from_api:
+        # alpha_T, non-social security benefits as a fraction of GDP
+        # source: https://data.imf.org/?sk=78d0bcc1-7a8f-44eb-8a2c-d4e472b8e64b&hide_uv=1
+        # alpha_T = Employment-related social benefits expense - Social security benefits expense
+        macro_parameters["alpha_T"] = [0.36 - 0.0]  # 2022 = 0.36
+
+        # alpha_G, gov't consumption expenditures as a fraction of GDP
+        # source: https://data.imf.org/?sk=23ca1c1d-e6a5-4f18-bc2e-7e215837f971&hide_uv=1
+        # alpha_G = Expense	- Interest expense - Social benefits expense
+        macro_parameters["alpha_G"] = [0.324 - 0.047 - 0.036]  # 2022 = 0.241
+
+        """"
+        Esimate the discount on sovereign yields relative to private debt
+        Follow the methodology in Li, Magud, Werner, Witte (2021)
+        available at:
+        https://www.imf.org/en/Publications/WP/Issues/2021/06/04/The-Long-Run-Impact-of-Sovereign-Yields-on-Corporate-Yields-in-Emerging-Markets-50224
+        discussion is here: https://github.com/EAPD-DRB/OG-ETH/issues/22
+        Steps:
+        1) Generate modelled corporate yields (corp_yhat) for a range of
+        sovereign yields (sov_y)  using the estimated equation in col 2 of
+        table 8 (and figure 3). 2) Estimate the OLS using sovereign yields
+        as the dependent variable
+        """
+
+        # # estimate r_gov_shift and r_gov_scale
+        sov_y = np.arange(20, 120) / 10
+        corp_yhat = 8.199 - (2.975 * sov_y) + (0.478 * sov_y**2)
+        corp_yhat = sm.add_constant(corp_yhat)
+        mod = sm.OLS(
+            sov_y,
+            corp_yhat,
+        )
+        res = mod.fit()
+        # First term is the constant and needs to be divided by 100 to have
+        # the correct unit. Second term is the coefficient
+        macro_parameters["r_gov_shift"] = [-res.params[0] / 100]
+        macro_parameters["r_gov_scale"] = [res.params[1]]
+        # Report new values
+        print(f"alpha_T updated from IMF data: {macro_parameters['alpha_T']}")
+        print(f"alpha_G updated from IMF data: {macro_parameters['alpha_G']}")
+        print(
+            f"r_gov_shift updated from IMF data: {macro_parameters['r_gov_shift']}"
+        )
+        print(
+            f"r_gov_scale updated from IMF data: {macro_parameters['r_gov_scale']}"
+        )
+    else:
+        print("Not updating alpha_T, alpha_G, r_gov_shift, r_gov_scale")
+
+    return macro_parameters