Economics

The Economics module provides insights for 60+ countries into key economic indicators such as the Consumer Price Index (CPI), Gross Domestic Product (GDP), Unemployment Rates and government interest rates. It can also be used as a standalone module.

To install the FinanceToolkit it simply requires the following:

pip install financetoolkit -U

get_gross_domestic_product

Get the Gross Domestic Product for a variety of countries over time from the OECD. The Gross Domestic Product is the total value of goods produced and services provided in a country during one year.

Note that the OECD source reports GDP on a per capita basis, i.e. the total Gross Domestic Product divided by the population of the country, whereas the Global Macro Database (GMDB) source reports the total (not per capita) figure. The two are also expressed in different units: the OECD source is in current-price US dollars per person converted with Purchasing Power Parities (PPPs), which makes the level comparable across countries, while the GMDB source is in millions of national currency. Both are annual.

The data is returned as levels. To obtain period-on-period changes (e.g. year on year or quarter on quarter growth), set growth=True and use lag to control how many periods back the comparison is made.

See definition: https://data.oecd.org/gdp/gross-domestic-product-gdp.htm

It is also possible to acquire the data from the Global Macro Database (GMDB) source which also provides inflation adjusted data. For more information see: https://www.globalmacrodata.com/documentation.html

Also known as: GDP, national income, economic growth.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• inflation_adjusted (bool, optional): Whether to return the inflation adjusted data. Defaults to False.
• gmdb_source (bool \| None, optional): If True, retrieves data from the GMDB source. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Gross Domestic Product

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_gross_domestic_product(inflation_adjusted=True, countries=['Netherlands', 'Germany', 'China'])

Which returns:

get_gross_domestic_product_deflator

Get the Gross Domestic Product Deflator for a variety of countries over time from the Global Macro Database (GMDB). The GDP deflator is a measure of the price of all domestically produced final goods and services in an economy relative to the price level in a base year which can vary per country.

The deflator is an index, set to 100 in the base year, which can vary per country, and is annual.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: GDP deflator, implicit price deflator.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Gross Domestic Product Deflator

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_gross_domestic_product_deflator(countries=['United States', 'Canada', 'Russian Federation'])

Which returns:

get_real_gross_domestic_product_usd

Get the Real Gross Domestic Product expressed in cross-country comparable US Dollars for a variety of countries over time from the Global Macro Database (GMDB). This is the inflation-adjusted GDP of a country converted into US Dollars, which makes it possible to directly compare the economic output of countries that use different currencies without having to perform the currency conversion or inflation adjustment yourself.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: real GDP in USD, cross-country comparable GDP.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Real Gross Domestic Product in US Dollars

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_real_gross_domestic_product_usd(countries=['United States', 'Japan', 'Germany'])

Which returns:

get_real_gross_domestic_product_per_capita

Get the Real Gross Domestic Product per Capita for a variety of countries over time from the Global Macro Database (GMDB). This is the inflation-adjusted Gross Domestic Product (GDP) divided by the total population of a country, which gives an indication of the average economic output (and by extension, living standard) per person.

Formula:

Real GDP per Capita = Real Gross Domestic Product / Population

This uses the Global Macro Database’s own precomputed per-capita series rather than dividing GDP by population manually, which avoids subtle mismatches that can arise from differences in population coverage or timing between the two underlying series.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: real GDP per capita, real income per capita, standard of living.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Real Gross Domestic Product per Capita

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_real_gross_domestic_product_per_capita(countries=['Netherlands', 'Germany', 'China'])

Which returns:

get_output_gap

Get the Output Gap for a variety of countries over time from the OECD Economic Outlook. The output gap is the difference between actual Gross Domestic Product (GDP) and estimated potential GDP, expressed as a percentage of potential GDP. Potential GDP is the level of output an economy can sustain over the long term without generating excess inflationary or disinflationary pressure, based on the full, non-inflationary use of its productive resources (labour, capital and technology).

A positive output gap indicates the economy is running above its long-run potential (an economic “boom”, typically associated with rising inflationary pressure), while a negative output gap indicates the economy is running below potential (an economic “slack”, typically associated with rising unemployment and disinflationary pressure). The output gap therefore complements indicators such as the Inflation Rate and Unemployment Rate as a measure of where an economy sits within the business cycle.

Formula:

Output Gap = (Actual GDP - Potential GDP) / Potential GDP

This data is only available on a yearly basis, since the OECD Economic Outlook is published as a set of annual projections and estimates.

Changed in v2.2.0: the result is now a decimal fraction (-0.0422) rather than the percentage of potential GDP the OECD publishes (-4.2231), matching every other rate and ratio in this class. Multiply by 100 to recover the published figure. Note that a small gap loses resolution at the default rounding of 4 decimals – pass a larger rounding when the sub-basis-point detail matters.

See definition: https://www.oecd.org/en/data/indicators/output-gaps.html

Also known as: business cycle gap, GDP gap.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Output Gap as a decimal fraction of potential GDP.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2018-01-01', end_date='2022-01-01')

economics.get_output_gap(countries=['United States', 'Germany', 'Japan'])

Which returns:

get_total_consumption

Get the Total Consumption for a variety of countries over time from the Global Macro Database (GMDB). Total Consumption is the total amount of money spent by households on consumer goods and services.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: household consumption, private consumption.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• inflation_adjusted (bool, optional): Whether to return the inflation adjusted data. Defaults to False.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Total Consumption

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2018-01-01')

total_consumption = economics.get_total_consumption()

total_consumption.loc[:, ['Netherlands', 'France', 'Poland']]

Which returns:

get_total_consumption_to_gdp_ratio

Get the Total Consumption to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Total Consumption to GDP Ratio is the ratio of the total amount of money spent by households on consumer goods and services to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.8100 for 81.00% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: consumption share of GDP.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Total Consumption to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2018-01-01')

total_consumption_to_gdp_ratio = economics.get_total_consumption_to_gdp_ratio()

total_consumption_to_gdp_ratio.loc[:, ['Netherlands', 'France', 'Poland']]

Which returns:

get_investment

Get the Investment for a variety of countries over time from the Global Macro Database (GMDB). Investment is the total amount of money spent by businesses on capital goods, such as machinery, equipment, and buildings.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: total investment, capital formation.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Investment

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2014-01-01')

investment = economics.get_investment()

investment.loc[:, ['United States', 'Portugal', 'China']]

Which returns:

get_investment_to_gdp_ratio

Get the Investment to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Investment to GDP Ratio is the ratio of the total amount of money spent by businesses on capital goods, such as machinery, equipment, and buildings to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.2248 for 22.48% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: investment rate.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Investment to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2019-01-01')

investment_to_gdp_ratio = economics.get_investment_to_gdp_ratio()

investment_to_gdp_ratio.loc[:, ['Australia', 'Japan', 'Turkey']]

Which returns:

get_fixed_investment

Get the Fixed Investment for a variety of countries over time from the Global Macro Database (GMDB). Fixed Investment is the total amount of money spent by businesses on capital goods, such as machinery, equipment, and buildings that are expected to last for more than one year.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: gross fixed capital formation, capital investment.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Fixed Investment

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01')

fixed_investment = economics.get_fixed_investment()

fixed_investment.loc[:, ['United Kingdom', 'Germany', 'France']]

Which returns:

get_fixed_investment_to_gdp_ratio

Get the Fixed Investment to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Fixed Investment to GDP Ratio is the ratio of the total amount of money spent by businesses on capital goods, such as machinery, equipment, and buildings that are expected to last for more than one year to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.2179 for 21.79% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: investment to GDP ratio.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Fixed Investment to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2000-01-01')

fixed_investment_to_gdp_ratio = economics.get_fixed_investment_to_gdp_ratio()

fixed_investment_to_gdp_ratio.loc[:, ['Austria', 'Germany', 'Switzerland']]

Which returns:

get_exports

Get the Exports for a variety of countries over time from the Global Macro Database (GMDB). Exports are the total amount of goods and services produced in a country that are sold to other countries.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: exports, trade exports.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Exports

As an example:

from financetoolkit import Economics

economics = Economics(start_date='1980-01-01', end_date='1990-01-01')

economics.get_exports(countries=['Netherlands', 'Germany', 'China'])

Which returns:

get_exports_to_gdp_ratio

Get the Exports to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Exports to GDP Ratio is the ratio of the total amount of goods and services produced in a country that are sold to other countries to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.1016 for 10.16% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: exports to GDP ratio, trade openness.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Exports to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_exports_to_gdp_ratio(countries=['United States', 'Canada', 'Russian Federation'])

Which returns:

get_imports

Get the Imports for a variety of countries over time from the Global Macro Database (GMDB). Imports are the total amount of goods and services produced in other countries that are bought by a country.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: imports, trade imports.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Imports

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2010-01-01')

economics.get_imports(countries=['United States', 'Canada', 'Mexico'])

Which returns:

get_imports_to_gdp_ratio

Get the Imports to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Imports to GDP Ratio is the ratio of the total amount of goods and services produced in other countries that are bought by a country to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.1213 for 12.13% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: imports to GDP ratio.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Imports to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2010-01-01')

economics.get_imports_to_gdp_ratio(countries=['United States', 'Canada', 'Mexico'])

Which returns:

get_trade_balance

Get the Trade Balance for a variety of countries over time from the Global Macro Database (GMDB). The Trade Balance is the difference between the total value of goods and services a country exports and the total value of goods and services it imports. A positive trade balance (a “trade surplus”) means a country exports more than it imports, while a negative trade balance (a “trade deficit”) means a country imports more than it exports.

Formula:

Trade Balance = Exports - Imports

The balance is annual and expressed in millions of national currency, with a negative value marking a trade deficit and a positive value a surplus.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: net exports, balance of trade.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Trade Balance

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01', end_date='2023-01-01')

economics.get_trade_balance(countries=['United States', 'Germany', 'China'])

Which returns:

get_current_account_balance

Get the Current Account Balance for a variety of countries over time from the Global Macro Database (GMDB). The Current Account Balance is the sum of the balance of trade (exports minus imports of goods and services), net factor income (such as interest and dividends) and net transfer payments (such as foreign aid).

The balance is annual and expressed in millions of national currency, with a negative value marking a current account deficit and a positive value a surplus.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: current account, trade balance, balance of payments.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Current Account Balance

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_current_account_balance(countries=['France', 'Germany', 'Italy'])

Which returns:

get_current_account_balance_to_gdp_ratio

Get the Current Account Balance to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Current Account Balance to GDP Ratio is the ratio of the sum of the balance of trade (exports minus imports of goods and services), net factor income (such as interest and dividends) and net transfer payments (such as foreign aid) to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (-0.0211 for -2.11% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: current account to GDP.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Current Account Balance to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_current_account_balance_to_gdp_ratio(countries=[
    'Poland', 'Turkey', 'United Kingdom'])

Which returns:

get_government_debt

Get the Government Debt for a variety of countries over time from the Global Macro Database (GMDB). Government Debt is the total amount of money that a government owes to creditors.

The stock is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: national debt, sovereign debt.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Debt

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_debt(countries=['United States', 'Canada', 'Mexico'])

Which returns:

get_government_debt_to_gdp_ratio

Get the Government Debt to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Government Debt to GDP Ratio is the ratio of the total amount of money that a government owes to creditors to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (1.3173 for 131.73% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: debt-to-GDP ratio, fiscal sustainability.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Debt to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_debt_to_gdp_ratio(countries=['Netherlands', 'Germany', 'China'])

Which returns:

get_government_revenue

Get the Government Revenue for a variety of countries over time from the Global Macro Database (GMDB). Government Revenue is the total amount of money that a government collects from taxes and other sources.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: government income, public revenue.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Revenue

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2019-01-01')

economics.get_government_revenue(countries=['United Kingdom', 'Canada', 'Japan'])

Which returns:

get_government_revenue_to_gdp_ratio

Get the Government Revenue to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Government Revenue to GDP Ratio is the ratio of the total amount of money that a government collects from taxes and other sources to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.3104 for 31.04% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: revenue to GDP ratio.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Revenue to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_revenue_to_gdp_ratio(countries=['United States', 'Canada', 'Russian Federation'])

Which returns:

get_government_tax_revenue

Get the Government Tax Revenue for a variety of countries over time from the Global Macro Database (GMDB). Government Tax Revenue is the total amount of money that a government collects from taxes.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: tax revenue, fiscal revenue.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Tax Revenue

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_tax_revenue(countries=['Kenya', 'Nigeria', 'South Africa'] )

Which returns:

get_government_tax_revenue_to_gdp_ratio

Get the Government Tax Revenue to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Government Tax Revenue to GDP Ratio is the ratio of the total amount of money that a government collects from taxes to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.1022 for 10.22% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: tax burden, tax to GDP ratio.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Tax Revenue to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_tax_revenue_to_gdp_ratio(
    countries=['United States', 'Canada', 'Mexico'])

Which returns:

get_government_expenditure

Get the Government Expenditure for a variety of countries over time from the Global Macro Database (GMDB). Government Expenditure is the total amount of money that a government spends on goods and services.

The level is annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: government spending, public expenditure.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Expenditure

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_expenditure(countries=['Japan', 'China', 'India'])

Which returns:

get_government_expenditure_to_gdp_ratio

Get the Government Expenditure to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Government Expenditure to GDP Ratio is the ratio of the total amount of money that a government spends on goods and services to the Gross Domestic Product (GDP).

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The ratio is expressed as a decimal fraction (0.3708 for 37.08% of GDP).

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: government spending to GDP.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Expenditure to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_expenditure_to_gdp_ratio(
    countries=['United States', 'Japan', 'Netherlands'])

Which returns:

get_government_deficit

Get the Government Deficit for a variety of countries over time from the Global Macro Database (GMDB). Government Deficit is the total amount of money that a government spends more than it collects from taxes and other sources. A government deficit is usually financed by borrowing money.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The series is signed as a fiscal balance rather than as a deficit, in millions of national currency: a negative value is a deficit (spending exceeding revenue) and a positive value is a surplus.

Also known as: budget deficit, fiscal deficit.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Deficit

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

economics.get_government_deficit(countries=['United States', 'Canada', 'Mexico'])

Which returns:

get_government_deficit_to_gdp_ratio

Get the Government Deficit to GDP Ratio for a variety of countries over time from the Global Macro Database (GMDB). The Government Deficit to GDP Ratio is the ratio of the total amount of money that a government spends more than it collects from taxes and other sources to the Gross Domestic Product (GDP). A government deficit is usually financed by borrowing money.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The series is signed as a fiscal balance rather than as a deficit, and expressed as a decimal fraction of GDP: -0.07068 means a deficit of 7.068% of GDP, and a positive value is a surplus.

Changed in v2.2.0: this used to be returned in percentage points. It is now a decimal fraction, matching every other ratio in the Finance Toolkit.

Also known as: deficit-to-GDP, fiscal balance.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Government Deficit to GDP Ratio

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01')

government_deficit_to_gdp_ratio = economics.get_government_deficit_to_gdp_ratio()

government_deficit_to_gdp_ratio.loc[:, ['New Zealand', 'Australia', 'United Kingdom']]

Which returns:

get_trust_in_government

Trust in government refers to the share of people who report having confidence in the national government. The data shown reflect the share of respondents answering “yes” (the other response categories being “no”, and “don’t know”) to the survey question: “In this country, do you have confidence in… national government?”

Due to small sample sizes, country averages for horizontal inequalities (by age, gender and education) are pooled between 2010-18 to improve the accuracy of the estimates.

The sample is ex ante designed to be nationally representative of the population aged 15 and over. The population-wide figure is returned – both sexes, all education levels – as an annual decimal fraction of that population (0.3933 for 39.33%). The breakdowns by sex and education level that the OECD publishes alongside it are not returned here.

See definition: https://data.oecd.org/gga/trust-in-government.htm

Also known as: political trust, institutional trust.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Trust in Government.

As an example:

from financetoolkit import Economics

economics = Economics()

trust_in_government = economics.get_trust_in_government()

trust_in_government.loc[:, ['United States', 'Greece', 'Japan']]

Which returns:

get_consumer_price_index

Consumer Price Index (CPI) is a measure that examines the average change in prices paid by consumers for goods and services over time. It is a measure of inflation.

By default, data comes from the Global Macro Database (GMDB), which is annual-only (base year 2010). Set oecd_source=True to instead retrieve monthly or quarterly data from the OECD (base year varies per country), useful for tracking inflation more closely in real time.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: CPI, cost of living index.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data. Only used when oecd_source=True; the GMDB source is always annual. Defaults to None.
• oecd_source (bool, optional): Whether to get the data from the OECD instead of the Global Macro Database (GMDB). Defaults to False.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Consumer Price Index.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2008-09-01', end_date='2020-03-01')

economics.get_consumer_price_index(countries=['Germany', 'France', 'Portugal'])

Which returns:

get_inflation_rate

Inflation Rate is the percentage change in the Consumer Price Index (CPI) from one period to another. It is a measure of the rate of price increases in the economy.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The rate is expressed as a decimal fraction (0.0412 for 4.1166%) on an annual basis. The GMDB extends its series with IMF World Economic Outlook projections, so the current year and any later years the end_date reaches are forecasts rather than outturns.

Changed in v2.2.0: this used to be returned in percentage points (4.1166 for 4.1166%). It is now a decimal fraction, matching every other rate in the Finance Toolkit.

Also known as: CPI-based inflation, price increases, consumer prices.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Inflation Rate.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2003-01-01', end_date='2009-03-01')

economics.get_inflation_rate(countries=['Germany', 'France', 'Portugal'])

Which returns:

get_producer_price_index

Get the Producer Price Index (PPI) for a variety of countries over time from the OECD. The PPI measures the average change over time in the prices received by domestic producers (manufacturing) for their output. Because producers tend to pass rising input costs on to their customers with a lag, the PPI is generally seen as a leading, upstream indicator of cost pressure that later shows up in the Consumer Price Index (CPI).

The index covers manufacturing output only, is not seasonally adjusted, and is set to 100 in the base year, which can vary per country.

The OECD stopped updating this series in its Key Economic Indicators dataset during 2023: annual values end in 2022, and monthly and quarterly values end in early 2023 for all but a couple of countries. A start_date after that point returns an empty DataFrame.

See definition: https://www.oecd.org/en/data/indicators/producer-prices-ppi.html

Also known as: PPI, wholesale prices, factory gate prices, upstream inflation.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Producer Price Index.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2018-01-01', end_date='2022-01-01')

economics.get_producer_price_index(
    countries=['United States', 'Germany'],
    period='yearly'
)

Which returns:

get_consumer_confidence_index

This consumer confidence indicator provides an indication of future developments of households consumption and saving, based upon answers regarding their expected financial situation, their sentiment about the general economic situation, unemployment and capability of savings.

An indicator above 100 signals a boost in the consumers’ confidence towards the future economic situation, as a consequence of which they are less prone to save, and more inclined to spend money on major purchases in the next 12 months. Values below 100 indicate a pessimistic attitude towards future developments in the economy, possibly resulting in a tendency to save more and consume less.

See definition: https://data.oecd.org/leadind/consumer-confidence-index-cci.htm

Also known as: consumer sentiment, spending outlook.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Consumer Confidence Index.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2008-09-01', end_date='2009-03-01')

economics.get_consumer_confidence_index(countries=['Germany', 'France', 'Portugal'])

Which returns:

get_business_confidence_index

This business confidence indicator provides information on future developments, based upon opinion surveys on developments in production, orders and stocks of finished goods in the industry sector. It can be used to monitor output growth and to anticipate turning points in economic activity.

Numbers above 100 suggest an increased confidence in near future business performance, and numbers below 100 indicate pessimism towards future performance.

See definition: https://data.oecd.org/leadind/business-confidence-index-bci.htm

Also known as: BCI, business sentiment.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Business Confidence Index.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2022-09-01', end_date='2023-03-01')

economics.get_business_confidence_index(countries=['Brazil', 'Canada', 'Costa Rica'])

Which returns:

get_composite_leading_indicator

The composite leading indicator (CLI) is designed to provide early signals of turning points in business cycles showing fluctuation of the economic activity around its long term potential level. CLIs show short-term economic movements in qualitative rather than quantitative terms.

The series returned is the OECD-harmonised, amplitude-adjusted index at monthly frequency, oscillating around a long-run average of 100: readings above 100 point to above-trend activity ahead and readings below 100 to below-trend activity. Coverage is narrower than the confidence indices – around 22 countries and aggregates.

See definition: https://data.oecd.org/leadind/composite-leading-indicator-cli.htm

Also known as: CLI, leading economic indicator.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Composite Leading Indicator.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2023-06-01', end_date='2023-12-01')

economics.get_composite_leading_indicator(countries=['United States', 'United Kingdom', 'Japan'])

Which returns:

get_house_prices

In most cases, the nominal house price index covers the sales of newly-built and existing dwellings, following the recommendations from the RPPI (Residential Property Prices Indices) manual.

The real house price index is given by the ratio of the nominal house price index to the consumers’ expenditure deflator in each country from the OECD national accounts database. Both indices are seasonally adjusted.

Both are an index based on 2015 = 100.

See definition: https://data.oecd.org/price/housing-prices.htm

It is also possible to get the data from the Global Macro Database (GMDB) by setting the gmdb_source to True.

Also known as: real estate prices, property prices, housing index.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• quarterly (bool \| None, optional): Whether to return the quarterly data or the annual data.
• inflation_adjusted (bool, optional): Whether to return the inflation adjusted data or the nominal data.
• gmdb_source (bool \| None, optional): Whether to get the data from the Global Macro Database (GMDB).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the House Prices.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01', end_date='2023-12-31')

economics.get_house_prices(
    countries=['Japan', 'Netherlands', 'Ireland'],
    quarterly=False,
    inflation_adjusted=True
)

Which returns:

get_rent_prices

The housing rent price index measures the prices paid for renting residential properties over time. Together with the house price index it is a key input into affordability and house ownership profitability measures such as the price to rent ratio.

This is an index based on 2015 = 100.

See definition: https://data.oecd.org/price/housing-prices.htm

Also known as: rental prices, housing costs, rent index.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• quarterly (bool \| None, optional): Whether to return the quarterly data or the annual data.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Rent Prices.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01', end_date='2023-12-31')

economics.get_rent_prices(
    countries=['Turkey', 'United States', 'United Kingdom'],
    quarterly=False)

Which returns:

get_household_savings_rate

Get the Gross Household Savings Rate for a variety of countries over time from the OECD’s Household Dashboard. The household savings rate is the share of household gross disposable income (adjusted for the net change in pension entitlements) that is saved rather than spent on final consumption.

It is a key input to consumption-smoothing and life-cycle/permanent-income theories of household behaviour, and a closely watched signal of both near-term consumption momentum (a falling savings rate can temporarily prop up spending even as income growth slows) and a household sector’s buffer against future income shocks. It complements Total Consumption (see get_total_consumption) - the two together show how much of household income is spent versus set aside.

The rate is seasonally adjusted and returned as a decimal fraction of adjusted gross disposable income (0.1177 for 11.77%). Because the denominator is adjusted for the net change in pension entitlements and the numerator is gross rather than net saving, this sits above the personal saving rate the BEA publishes for the United States.

See definition: https://data-explorer.oecd.org/vis?df[ds]=dsDisseminateFinalDMZ&df[id]=DSD_HHDASH%40DF_HHDASH_INDIC

Also known as: household savings ratio, personal savings rate.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• quarterly (bool \| None, optional): Whether to return the quarterly data or the annual data.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Household Savings Rate.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01', end_date='2022-12-31')

economics.get_household_savings_rate(
    countries=['United States', 'Germany'],
    quarterly=False)

Which returns:

get_household_debt_to_income_ratio

Get the Household Debt to Disposable Income Ratio for a variety of countries over time from the OECD’s Household Dashboard. This expresses total household gross debt (loans and debt securities) as a share of household gross disposable income, returned as a decimal ratio (1.0014 means debt equals 100.14% of income).

It is a standard household-leverage indicator used in financial-stability analysis: a high or rapidly rising ratio signals households are more exposed to income shocks or interest rate increases (debt-servicing costs rise directly with rates on variable-rate or refinanced debt), and has historically preceded credit-cycle downturns (e.g. in the lead-up to the 2008 financial crisis). It is the household- sector analogue to government debt (see get_government_debt_to_gdp_ratio) - the two together give a fuller picture of an economy’s overall leverage.

See definition: https://data-explorer.oecd.org/vis?df[ds]=dsDisseminateFinalDMZ&df[id]=DSD_HHDASH%40DF_HHDASH_INDIC

Also known as: household leverage ratio, debt-to-income ratio.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• quarterly (bool \| None, optional): Whether to return the quarterly data or the annual data.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Household Debt to Income Ratio.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2015-01-01', end_date='2022-12-31')

economics.get_household_debt_to_income_ratio(
    countries=['United States', 'Australia'],
    quarterly=False)

Which returns:

get_share_prices

Share price indices are calculated from the prices of common shares of companies traded on national or foreign stock exchanges. They are usually determined by the stock exchange, using the closing daily values for the monthly data, and normally expressed as simple arithmetic averages of the daily data.

A share price index measures how the value of the stocks in the index is changing, a share return index tells the investor what their “return” is, meaning how much money they would make as a result of investing in that basket of shares.

A price index measures changes in the market capitalisation of the basket of shares in the index whereas a return index adds on to the price index the value of dividend payments, assuming they are re-invested in the same stocks. Occasionally agencies such as central banks will compile share indices.

This uses 2015 as the base year (= 100)

See definition: https://data.oecd.org/price/share-prices.htm

Also known as: stock market index, equity index, market performance.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Share Prices.

As an example:

from financetoolkit import Economics

economics = Economics(start_date="2013-01-01")

economics.get_share_prices(countries=['Turkey', 'Belgium', 'Australia'])

Which returns:

get_exchange_rates

Exchange rates are defined as the price of one country’s currency in relation to another country’s currency. This indicator is measured in terms of national currency per US dollar.

See definition: https://data.oecd.org/conversion/exchange-rates.htm

It is also possible to get the data from the Global Macro Database (GMDB) by setting the gmdb_source to True.

Both sources are quoted the same way (national currency per US dollar), but the OECD source omits the United States itself, since the rate is trivially 1, whereas the GMDB source carries it as 1.0. Only the OECD source supports monthly and quarterly frequency; the GMDB is annual only, so the period argument has no effect when gmdb_source is True.

Also known as: currency exchange, FX rates, foreign exchange rates.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data.
• gmdb_source (bool \| None, optional): Whether to get the data from the Global Macro Database (GMDB).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Exchange Rates.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2000-01-01', end_date='2010-12-31')

economics.get_exchange_rates(countries=['Japan', 'Indonesia', "China"])

Which returns:

get_real_effective_exchange_rate

Get the Real Effective Exchange Rate (REER) for a variety of countries over time from the Global Macro Database (GMDB). The REER is a trade-weighted average of a country’s currency relative to a basket of other major currencies, adjusted for relative price levels (inflation) between the country and its trading partners.

Unlike a simple bilateral exchange rate, the REER captures a currency’s overall competitiveness: a rising REER indicates that a country’s exports are becoming more expensive (and imports cheaper) relative to its trading partners after accounting for inflation differentials, while a falling REER indicates the opposite. The index is set to 100 in the base year, which can vary per country.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: REER, trade-weighted exchange rate, currency competitiveness index.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Real Effective Exchange Rate

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2018-01-01')

economics.get_real_effective_exchange_rate(countries=['United States', 'Japan', 'Netherlands'])

Which returns:

get_money_supply

Money Supply is the total amount of money that is in circulation in a country. It includes currency, demand deposits, and other liquid assets that can be easily converted into cash. Money supply is an important economic indicator that the Federal Reserve uses to implement its monetary policy.

Money supply can be divided into five categories: M0, M1, M2, M3 and M4. - M0: The total of all physical currency, plus accounts at the central bank that can be exchanged for physical currency. - M1: The total of all physical currency part of bank reserves + the amount in demand accounts (“checking” or “current” accounts). - M2: M1 + most savings accounts, money market accounts, retail money market mutual funds, and small denomination time deposits. - M3: M2 + large time deposits, institutional money market funds, short-term repurchase agreements, and other larger liquid assets. - M4: M3 + all other financial assets.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The aggregates are annual and expressed in millions of national currency, so levels are not comparable across countries with different currencies, but growth rates are. Not every country publishes every aggregate; the ones it does not are NaN.

Also known as: M1, M2, M3, monetary aggregate.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• measure (str \| None, optional): Which single aggregate to return, one of ‘M0’, ‘M1’, ‘M2’, ‘M3’ or ‘M4’. Defaults to None, which returns all five with the aggregate as the first level of the column index.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Money Supply

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2010-01-01', end_date='2020-12-31')

money_supply = economics.get_money_supply(
    countries=['Netherlands', 'Germany', 'United States'],
    measure='M2'
)

Which returns:

get_central_bank_policy_rate

The Central Bank Policy Rate is the interest rate that a central bank sets on its loans and advances to a commercial bank. This interest rate is used by the monetary authorities to control inflation and stabilize the country’s currency.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

The rate is annual and expressed as a decimal fraction per annum (0.0538 for 5.375%), taken at the end of the year rather than averaged over it.

Changed in v2.2.0: this used to be returned in percentage points (5.375 for 5.375%). It is now a decimal fraction, matching every other rate in the Finance Toolkit.

Also known as: policy rate, benchmark rate, base rate.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Central Bank Policy Rate

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2021-01-01', end_date='2025-12-31')

economics.get_central_bank_policy_rate(countries=['Netherlands', 'Germany', 'United States'])

Which returns:

get_short_term_interest_rate

Short-term interest rates are the rates at which short-term borrowings are effected between financial institutions or the rate at which short-term government paper is issued or traded in the market. Short-term interest rates are generally averages of daily rates, measured as a percentage.

Short-term interest rates are based on three-month money market rates where available. Typical standardised names are “money market rate” and “treasury bill rate”. The OECD source specifically returns the 3-month interbank offered rate.

See definition: https://data.oecd.org/interest/short-term-interest-rates.htm

It is also possible to get the data from the Global Macro Database (GMDB) by setting the gmdb_source to True.

Both sources return the rate as a decimal fraction per annum (0.0513 for 5.13%), so the two are directly interchangeable. Only the OECD source supports monthly and quarterly frequency; the GMDB is annual only, so the period argument has no effect when gmdb_source is True.

Changed in v2.2.0: the GMDB source previously returned percentage points (5.13 for 5.13%) while the OECD source returned a decimal fraction. The GMDB series is now divided by 100 so both sources agree; divide any hard-coded comparison by 100.

Also known as: 3-month rate, money market rate, short-term yield.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data.
• gmdb_source (bool \| None, optional): Whether to get the data from the Global Macro Database (GMDB).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Short Term Interest Rate.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2023-05-01')

economics.get_short_term_interest_rate(
    countries=['Japan', 'United States', 'China'],
    gmdb_source=False,
    period='quarterly'
)

Which returns:

get_long_term_interest_rate

Long-term interest rates refer to government bonds maturing in ten years. Rates are mainly determined by the price charged by the lender, the risk from the borrower and the fall in the capital value. Long-term interest rates are generally averages of daily rates, measured as a percentage. These interest rates are implied by the prices at which the government bonds are traded on financial markets, not the interest rates at which the loans were issued.

In all cases, they refer to bonds whose capital repayment is guaranteed by governments. Long-term interest rates are one of the determinants of business investment. Low long term interest rates encourage investment in new equipment and high interest rates discourage it. Investment is, in turn, a major source of economic growth

See definition: https://data.oecd.org/interest/long-term-interest-rates.htm

It is also possible to get the data from the Global Macro Database (GMDB) by setting the gmdb_source to True.

Both sources return the rate as a decimal fraction per annum (0.0357 for 3.57%), so the two are directly interchangeable. Only the OECD source supports monthly and quarterly frequency; the GMDB is annual only, so the period argument has no effect when gmdb_source is True.

Changed in v2.2.0: the GMDB source previously returned percentage points (3.57 for 3.57%) while the OECD source returned a decimal fraction. The GMDB series is now divided by 100 so both sources agree; divide any hard-coded comparison by 100.

Also known as: 10-year yield, government bond rate, long-term yield.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data.
• gmdb_source (bool \| None, optional): Whether to get the data from the Global Macro Database (GMDB).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Long Term Interest Rate.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2023-05-01', end_date='2023-12-31')

economics.get_long_term_interest_rate(
    countries=['Japan', 'United States', 'Brazil'],
    gmdb_source=False,
    period='monthly'
)

Which returns:

get_real_interest_rate

Get the Real Interest Rate for a variety of countries over time. The Real Interest Rate is the nominal interest rate adjusted for inflation, and reflects the true cost of borrowing (or the true return earned on savings) once the erosion of purchasing power by inflation is taken into account.

Formula (Fisher equation, approximation):

Real Interest Rate = Nominal Interest Rate - Inflation Rate

The nominal interest rate is either the Long Term Interest Rate (the 10-year government bond yield) or the Short Term Interest Rate (the 3-month money market rate), selected via the rate_type parameter. The Inflation Rate is only available on an annual basis (see get_inflation_rate), which comes from the Global Macro Database (GMDB). Both legs are annual decimal fractions (0.05 for 5%) whichever source is used, so they line up directly for the subtraction and the result is itself a decimal fraction (-0.0016 for a real rate of -0.16%).

Changed in v2.2.0: this used to be returned in percentage points, because the GMDB legs were percentage points and the OECD nominal rate was multiplied by 100 to match them. The GMDB series are now decimal fractions and that rescaling has been removed, so the result is 100x smaller than in v2.1.x.

A negative real interest rate means that, after inflation, savers are effectively losing purchasing power and borrowers are being subsidized in real terms; this occurred in many countries during the 2021-2022 inflation surge.

Also known as: real yield, inflation-adjusted interest rate.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rate_type (str, optional): Which nominal interest rate to use. Can be ‘long_term’ (10-year government bond yield) or ‘short_term’ (3-month money market rate). Defaults to ‘long_term’.
• gmdb_source (bool \| None, optional): Whether to get the nominal interest rate from the Global Macro Database (GMDB) instead of the OECD. Defaults to None, which falls back to the gmdb_source set on the Economics class (True by default).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Real Interest Rate

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2018-01-01', end_date='2023-01-01')

economics.get_real_interest_rate(countries=['United States', 'Germany', 'Japan'])

Which returns:

get_yield_curve_slope

Get the Yield Curve Slope for a variety of countries over time. The Yield Curve Slope is the difference between the Long Term Interest Rate (the 10-year government bond yield) and the Short Term Interest Rate (the 3-month money market rate), and summarizes the overall shape of the yield curve in a single number.

Formula:

Yield Curve Slope = Long Term Interest Rate - Short Term Interest Rate

A positive (upward-sloping) yield curve is the historical norm and reflects investors demanding a premium for locking up money for longer. A negative (inverted) yield curve, where short-term rates exceed long-term rates, has historically been one of the more reliable leading indicators of an upcoming recession, as it signals that markets expect the central bank to cut rates in response to a weakening economy.

Both legs are decimal fractions (0.05 for 5%) whichever source is used, so the result is itself a decimal fraction (-0.0122 for an inversion of 1.22 percentage points), matching the convention used by get_misery_index and get_real_interest_rate.

Changed in v2.2.0: this used to be returned in percentage points, because the GMDB legs were percentage points and the OECD legs were multiplied by 100 to match them. The GMDB series are now decimal fractions and that rescaling has been removed, so the result is 100x smaller than in v2.1.x.

Also known as: term spread, 10Y-3M spread, curve inversion.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data.
• gmdb_source (bool \| None, optional): Whether to get the data from the Global Macro Database (GMDB).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Yield Curve Slope

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2021-01-01', end_date='2023-12-31')

economics.get_yield_curve_slope(
    countries=['United States', 'Germany', 'Japan'],
    period='yearly'
)

Which returns:

get_renewable_energy

Renewable energy is defined as the contribution of renewables to total primary energy supply (TPES). Renewables include the primary energy equivalent of hydro (excluding pumped storage), geothermal, solar, wind, tide and wave sources.

Energy derived from solid biofuels, biogasoline, biodiesels, other liquid biofuels, biogases and the renewable fraction of municipal waste are also included. Biofuels are defined as fuels derived directly or indirectly from biomass (material obtained from living or recently living organisms).

This includes wood, vegetal waste (including wood waste and crops used for energy production), ethanol, animal materials/wastes and sulphite lyes. Municipal waste comprises wastes produced by the residential, commercial and public service sectors that are collected by local authorities for disposal in a central location for the production of heat and/or power.

This indicator is the renewable share of total primary energy supply, returned as an annual decimal fraction (0.0872 for 8.72%).

See definition: https://data.oecd.org/energy/renewable-energy.htm

Also known as: clean energy, green energy, renewable energy share.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Renewable Energy Percentage.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2010-01-01', end_date='2020-01-01')

economics.get_renewable_energy(countries=['Austria', 'Germany', 'United States'])

Which returns:

get_carbon_footprint

The carbon footprint is a measure of the total amount of greenhouse gases produced to directly and indirectly support human activities, usually expressed in equivalent tons of carbon dioxide (CO2).

The carbon footprint is a subset of the ecological footprint and of the more comprehensive Life Cycle Assessment (LCA). An individual, nation, or organization’s carbon footprint can be measured by undertaking a GHG emissions assessment or other calculative activities denoted as carbon accounting.

The data is sourced from the greenhouse gas emissions per capita indicator of the OECD’s How’s Life? well-being database (dataset DSD_HSL@DF_HSL_FWB, indicator 12_9), so the figures are expressed in tonnes of CO2 equivalent per person, on an annual basis.

This series currently ends in 2020, so a date range that starts after that returns an empty DataFrame and later years are absent rather than NaN.

Also known as: CO2 emissions, carbon emissions, greenhouse gas.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Carbon Footprint.

As an example:

from financetoolkit import Economics

economics = Economics(start_date="2010-01-01", end_date="2020-01-01")

economics.get_carbon_footprint(countries=['Germany', 'United States', 'Poland'])

Which returns:

get_unemployment_rate

The unemployed are people of working age who are without work, are available for work, and have taken specific steps to find work. The uniform application of this definition results in estimates of unemployment rates that are more internationally comparable than estimates based on national definitions of unemployment.

This indicator is measured in numbers of unemployed people as a percentage of the labour force and it is seasonally adjusted. The labour force is defined as the total number of unemployed people plus those in employment. Data are based on labour force surveys (LFS).

For European Union countries where monthly LFS information is not available, the monthly unemployed figures are estimated by Eurostat.

See definition: https://data.oecd.org/unemp/unemployment-rate.htm

It is also possible to get the data from the Global Macro Database (GMDB) by setting the gmdb_source to True.

Both sources return the rate as a decimal fraction of the labour force (0.036 for 3.6%), so the two are directly interchangeable. Only the OECD source supports monthly and quarterly frequency; the GMDB is annual only, so the period argument has no effect when gmdb_source is True.

Changed in v2.2.0: the GMDB source previously returned percentage points (3.6 for 3.6%) while the OECD source returned a decimal fraction. The GMDB series is now divided by 100 so both sources agree; divide any hard-coded comparison by 100.

Also known as: jobless rate, labor market, unemployment level.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• period (str \| None, optional): Whether to return the monthly, quarterly or the annual data.
• gmdb_source (bool \| None, optional): Whether to get the data from the Global Macro Database (GMDB).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Unemployment Rate.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2021-03-01', end_date='2023-01-01')

economics.get_unemployment_rate(
    countries=['Germany', 'United States', 'Japan'],
    gmdb_source=False,
    period='quarterly'
)

Which returns:

get_misery_index

Get the Misery Index for a variety of countries over time. The Misery Index is a simple gauge of the overall economic discomfort felt by the average person, combining the two economic ills that are most directly and visibly felt by households: unemployment and rising prices.

Formula:

Misery Index = Unemployment Rate + Inflation Rate

The Unemployment Rate and Inflation Rate are both retrieved as annual decimal fractions (0.05 for 5%) whichever source is used, so they line up directly for the addition and the result is itself a decimal fraction (0.0774 for a Misery Index of 7.74).

Changed in v2.2.0: this used to be returned in percentage points, because both GMDB legs were percentage points and the OECD unemployment rate was multiplied by 100 to match them. The GMDB series are now decimal fractions and that rescaling has been removed, so the result is 100x smaller than in v2.1.x.

A higher Misery Index indicates a more uncomfortable economic climate for the average household, while a lower value indicates a more comfortable one. It was originally popularized by economist Arthur Okun.

Also known as: economic discomfort index, Okun’s misery index.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• gmdb_source (bool \| None, optional): Whether to get the unemployment rate from the Global Macro Database (GMDB) instead of the OECD. Defaults to None, which falls back to the gmdb_source set on the Economics class (True by default).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data. Defaults to False.
• lag (int, optional): The number of periods to lag the growth data. Defaults to 1.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Misery Index

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2018-01-01', end_date='2023-01-01')

economics.get_misery_index(countries=['United States', 'Germany', 'Japan'])

Which returns:

get_labour_productivity

GDP per hour worked is a measure of labour productivity. It measures how efficiently labour input is combined with other factors of production and used in the production process. Labour input is defined as total hours worked of all persons engaged in production. Labour productivity only partially reflects the productivity of labour in terms of the personal capacities of workers or the intensity of their effort.

The ratio between the output measure and the labour input depends to a large degree on the presence and/or use of other inputs (e.g. capital, intermediate inputs, technical, organisational and efficiency change, economies of scale).

The level is reported in US dollars per hour worked at constant prices (currently referenced to 2020), converted with Purchasing Power Parities (PPPs) so that it is comparable across countries, for the total economy and on an annual basis. It is a level rather than an index, so a value of 61.36 means 61.36 PPP-converted US dollars of GDP produced per hour worked.

See definition: https://data.oecd.org/lprdty/gdp-per-hour-worked.htm

Also known as: labor productivity, output per worker.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Labour Productivity.

As an example:

from financetoolkit import Economics

economics = Economics()

economics.get_labour_productivity(countries=['Bulgaria', 'Croatia', 'Spain'])

Which returns:

get_income_inequality

Income is defined as household disposable income in a particular year. It consists of earnings, self-employment and capital income and public cash transfers; income taxes and social security contributions paid by households are deducted. The income of the household is attributed to each of its members, with an adjustment to reflect differences in needs for households of different sizes.

The Gini coefficient is based on the comparison of cumulative proportions of the population against cumulative proportions of income they receive, and it ranges between 0 in the case of perfect equality and 1 in the case of perfect inequality.

One Gini coefficient is returned per country, for the total population and on the OECD’s current income definition (in use since 2012). The other inequality measures published alongside it in the same dataflow (the P90/P10, P90/P50 and P50/P10 decile ratios, the Palma ratio and the S80/S20 quintile share) are not returned here.

See definition: https://data.oecd.org/inequality/income-inequality.htm

Also known as: Gini coefficient, income distribution.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Income Inequality.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2013-01-01', end_date='2021-12-31')

economics.get_income_inequality(countries=['United States', 'Germany', 'Japan'])

Which returns:

get_population_statistics

Population is defined as all nationals present in, or temporarily absent from a country, and aliens permanently settled in a country. This indicator shows the number of people that usually live in an area. Growth rates are the annual changes in population resulting from births, deaths and net migration during the year.

Total population includes the following:

• national armed forces stationed abroad; merchant seamen at sea;
• diplomatic personnel located abroad;
• civilian aliens resident in the country;
• displaced persons resident in the country.

However, it excludes the following:

• foreign armed forces stationed in the country;
• foreign diplomatic personnel located in the country;
• civilian aliens temporarily in the country.

Population projections are a common demographic tool. They provide a basis for other statistical projections, helping governments in their decision making.

The Global Macro Database (GMDB) source returns a single total population series per country, in millions of people. The OECD source additionally breaks the total down by gender, giving a Population, Men and Women series for each country, and reports a plain count of persons rather than millions. Both are annual, and the OECD source uses the historical (observed) series rather than its projections.

See definition: https://data.oecd.org/pop/population.htm

It is also possible to get the data from the Global Macro Database (GMDB) by setting the gmdb_source to True.

Also known as: demographic data, census data.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• gmdb_source (bool \| None, optional): Whether to get the data from the Global Macro Database (GMDB).
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Population Statistics.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2010-01-01', end_date='2019-01-01')

economics.get_population_statistics(countries='Japan')

Which returns:

get_poverty_rate

The poverty rate is the ratio of the number of people (in a given age group) whose income falls below the poverty line; taken as half the median household income of the total population.

However, two countries with the same poverty rates may differ in terms of the relative income-level of the poor.

See definition: https://data.oecd.org/inequality/poverty-rate.htm

Also known as: poverty rate, income poverty.

Args:

• countries (list[str] \| str \| None, optional): The countries to include in the data. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Poverty Rates.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2012-01-01', end_date='2020-01-01')

economics.get_poverty_rate(countries='Portugal')

Which returns:

get_sovereign_debt_crisis

Get the Sovereign Debt Crisis dummy for a variety of countries over time from the Global Macro Database (GMDB). Unlike the other indicators in this module, this is a binary (0 = no crisis, 1 = crisis) Reinhart & Rogoff style crisis-dating series rather than a continuous economic series: a value of 1 marks a year in which a country was undergoing a sovereign debt crisis (e.g. a default or restructuring of government debt), and 0 marks a year in which it was not.

The crisis dating stops well short of the present – the series currently ends in 2017 – so recent years are NaN rather than 0.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: sovereign default, debt crisis dummy.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Sovereign Debt Crisis dummy

As an example:

from financetoolkit import Economics

economics = Economics(start_date='1980-01-01')

economics.get_sovereign_debt_crisis(countries='Argentina')

Which returns:

get_currency_crisis

Get the Currency Crisis dummy for a variety of countries over time from the Global Macro Database (GMDB). Unlike the other indicators in this module, this is a binary (0 = no crisis, 1 = crisis) Reinhart & Rogoff style crisis-dating series rather than a continuous economic series: a value of 1 marks a year in which a country was undergoing a currency crisis (e.g. a sharp, disorderly depreciation or collapse of the exchange rate), and 0 marks a year in which it was not.

The crisis dating stops well short of the present – the series currently ends in 2017 – so recent years are NaN rather than 0.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: currency collapse, exchange rate crisis dummy.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Currency Crisis dummy

As an example:

from financetoolkit import Economics

economics = Economics(start_date='1990-01-01')

economics.get_currency_crisis(countries='Turkey')

Which returns:

get_banking_crisis

Get the Banking Crisis dummy for a variety of countries over time from the Global Macro Database (GMDB). Unlike the other indicators in this module, this is a binary (0 = no crisis, 1 = crisis) Reinhart & Rogoff style crisis-dating series rather than a continuous economic series: a value of 1 marks a year in which a country was undergoing a systemic banking crisis (e.g. bank runs, large-scale bank failures or government intervention to prevent them), and 0 marks a year in which it was not.

The crisis dating stops well short of the present – the series currently ends in 2020 – so recent years are NaN rather than 0.

Data comes from the Global Macro Database (GMDB), further information about the variable can be found within https://www.globalmacrodata.com/documentation.html

Also known as: banking panic, financial crisis dummy, systemic banking crisis.

Args:

• countries (list[str] \| str \| None, optional): A list of countries or a single country to include in the results. Defaults to None.
• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods (e.g. a trailing-4-quarter sum). Defaults to None.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A DataFrame containing the Banking Crisis dummy

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2005-01-01')

economics.get_banking_crisis(countries=['United States', 'United Kingdom'])

Which returns:

get_nonfarm_payrolls

Get Total Nonfarm Payroll Employment for the United States from the Bureau of Labor Statistics (via FRED).

Nonfarm Payrolls is the headline monthly employment report and one of the most closely watched real-activity indicators in macroeconomics: it counts the number of paid US workers excluding farm employees, general government employees, private household employees and nonprofit organization employees. Sharp month-over-month changes are a core input to business-cycle dating (used directly by the NBER’s Business Cycle Dating Committee) and, through Okun’s Law, are closely tied to changes in the Unemployment Rate (see get_unemployment_rate).

The series is the monthly level of employment in thousands of persons, seasonally adjusted, so 156857 means 156.857 million jobs – not the monthly change that the headline “jobs added” number refers to. Use growth=True for that change.

Requires a free FRED API key, see the fred_api_key parameter of the Economics class.

See definition: https://fred.stlouisfed.org/series/PAYEMS

Also known as: NFP, nonfarm employment, the “jobs report”.

Args:

• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods. Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A single-column (“United States”) DataFrame of nonfarm payroll employment, in thousands of persons.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01', fred_api_key='FRED_API_KEY')

economics.get_nonfarm_payrolls()

Which returns:

get_initial_jobless_claims

Get weekly Initial Claims for Unemployment Insurance for the United States from the Department of Labor (via FRED).

Initial Jobless Claims counts the number of individuals filing for unemployment insurance for the first time in a given week. Because it is reported weekly (versus Nonfarm Payrolls’ monthly cadence, see get_nonfarm_payrolls) and captures layoffs essentially in real time, it is one of the most timely leading indicators of labor-market deterioration and a core component of the Conference Board’s Leading Economic Index.

Requires a free FRED API key, see the fred_api_key parameter of the Economics class.

See definition: https://fred.stlouisfed.org/series/ICSA

Also known as: initial claims, new unemployment claims.

Args:

• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods. Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A single-column (“United States”) DataFrame of weekly initial jobless claims, seasonally adjusted.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01', fred_api_key='FRED_API_KEY')

economics.get_initial_jobless_claims()

Which returns:

get_retail_sales

Get Advance Retail Sales (Retail and Food Services) for the United States from the Census Bureau (via FRED).

Retail Sales measures nominal spending at retail and food-service establishments. Since Personal Consumption Expenditures make up roughly two-thirds to three-quarters of US GDP, this monthly, high-frequency series is a core input to real-time (nowcast) GDP estimates such as the Federal Reserve Bank of Atlanta’s GDPNow.

The series is monthly, in millions of US dollars, seasonally adjusted, and covers retail trade and food services. It is nominal, so growth=True mixes volume and price changes together; compare against the Consumer Price Index to separate the two.

Requires a free FRED API key, see the fred_api_key parameter of the Economics class.

See definition: https://fred.stlouisfed.org/series/RSAFS

Also known as: retail trade, consumer spending (proxy).

Args:

• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods. Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A single-column (“United States”) DataFrame of total retail and food services sales, in millions of dollars.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01', fred_api_key='FRED_API_KEY')

economics.get_retail_sales()

Which returns:

get_industrial_production_index

Get the Industrial Production Index for the United States from the Federal Reserve’s G.17 statistical release (via FRED).

The Industrial Production Index measures real output in manufacturing, mining, and electric and gas utilities. Unlike survey-based sentiment indices, it is a hard, quantity-based measure of physical production and is one of the four coincident indicators the NBER’s Business Cycle Dating Committee uses to date US recessions (alongside real personal income, real manufacturing/trade sales and, see get_nonfarm_payrolls, nonfarm payroll employment).

Requires a free FRED API key, see the fred_api_key parameter of the Economics class.

See definition: https://fred.stlouisfed.org/series/INDPRO

Also known as: IP index, industrial output.

Args:

• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods. Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A single-column (“United States”) DataFrame of the Industrial Production Index (2017 = 100).

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01', fred_api_key='FRED_API_KEY')

economics.get_industrial_production_index()

Which returns:

get_housing_starts

Get Housing Starts (Total New Privately-Owned Housing Units Started) for the United States from the Census Bureau (via FRED).

Housing Starts counts the number of new residential construction projects that have begun in a given month. Residential investment is one of the most interest-rate-sensitive components of GDP, and construction activity leads the broader business cycle (it typically turns down before a recession and turns up before a recovery), making Housing Starts one of the ten components of the Conference Board’s Leading Economic Index.

Requires a free FRED API key, see the fred_api_key parameter of the Economics class.

See definition: https://fred.stlouisfed.org/series/HOUST

Also known as: new residential construction.

Args:

• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods. Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A single-column (“United States”) DataFrame of new housing starts, in thousands of units, seasonally adjusted annual rate.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01', fred_api_key='FRED_API_KEY')

economics.get_housing_starts()

Which returns:

get_real_personal_income

Get Real Personal Income Excluding Current Transfer Receipts for the United States from the Bureau of Economic Analysis (via FRED).

This is the exact series (not a proxy) the NBER’s Business Cycle Dating Committee uses as one of its four primary coincident indicators for dating US recessions - alongside Nonfarm Payrolls (see get_nonfarm_payrolls), the Industrial Production Index (see get_industrial_production_index) and Real Personal Consumption Expenditures. It measures aggregate household income from wages, investments and proprietors’ income, deliberately excluding government transfer payments (e.g. unemployment insurance, Social Security) so that the series reflects income generated by ongoing economic activity rather than the fiscal cushioning that automatically increases during a downturn.

Requires a free FRED API key, see the fred_api_key parameter of the Economics class.

See definition: https://fred.stlouisfed.org/series/W875RX1

Also known as: RPI less transfers, NBER real income indicator.

Args:

• rolling (int, optional): The rolling window size to use for smoothing the data (simple moving average). Defaults to None.
• trailing (int, optional): The trailing window size to use for summing the data over trailing periods. Defaults to None.
• growth (bool, optional): Whether to return the growth data or the actual data.
• lag (int, optional): The number of periods to lag the data by.
• standardize (bool, optional): Whether to standardize (Z-Score) the result. When combined with growth=True, standardizes the growth values instead of the raw values. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: A single-column (“United States”) DataFrame of real personal income excluding current transfer receipts, in billions of chained 2017 dollars.

As an example:

from financetoolkit import Economics

economics = Economics(start_date='2020-01-01', fred_api_key='FRED_API_KEY')

economics.get_real_personal_income()

Which returns: