pydeflate 1.4.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

pydeflate/deflate/deflator.py

@@ -1,78 +0,0 @@
-"""Defines the deflator class"""
-
-from dataclasses import dataclass
-
-import numpy as np
-import pandas as pd
-
-from pydeflate.get_data.deflate_data import Data
-from pydeflate.get_data.exchange_data import Exchange
-
-
-@dataclass
-class Deflator:
-    base_year: int
-    exchange_obj: Exchange
-    deflator_obj: Data
-    deflator_method: str
-    source_currency: str = "LCU"
-    target_currency: str = "USA"
-    to_current: bool = False
-    _xe_df: pd.DataFrame | None = None
-    _xe_deflator_df: pd.DataFrame | None = None
-    _price_deflator_df: pd.DataFrame | None = None
-    """A class to produce deflators based on the given parameters.
-    
-    Deflators take into account changes in prices and the evolution of currency exchange
-    values. They compensate for both factors in order to produce a standard unit of 
-    measurement, regardless of the year of the flow.
-    
-    Args:
-        base_year: the year in which the deflator equals 100 (if the source and target
-        currency are equal).
-        Exchange: the exchange rate object.
-        price: the price data oject.
-        source_currency: the ISO3 code of the country which uses the source currency
-        target_currency: the ISO3 code of the country which used the target currency
-        _deflator_df: the resulting DataFrame containing the deflators data.
-    """
-
-    def __post_init__(self):
-        # Exchange deflator DataFrame, including any currency conversion
-        self._xe_deflator_df = self.exchange_obj.exchange_deflator(
-            source_iso=self.source_currency,
-            target_iso=self.target_currency,
-            base_year=self.base_year,
-        )
-
-        # Price deflator DataFrame
-        self._price_deflator_df = self.deflator_obj.get_deflator(
-            base_year=self.base_year, method=self.deflator_method
-        )
-
-    def get_deflator(self) -> pd.DataFrame:
-        """Get the deflator DataFrame"""
-
-        # Merge the price and currency exchange deflators
-        df = self._price_deflator_df.merge(
-            self._xe_deflator_df,
-            on=["iso_code", "year"],
-            how="left",
-            suffixes=("_def", "_xe"),
-        )
-
-        # Calculate the deflator
-        df = (
-            df.assign(
-                value=round(100 * df.value_def / df.value_xe, 6)
-                if not self.to_current
-                else round(100 * df.value_xe / df.value_def, 6)
-            )
-            .filter(["iso_code", "year", "value"], axis=1)
-            .assign(value=lambda d: d.value.replace(0, np.nan))
-            .dropna(subset=["value"])
-            .reset_index(drop=True)
-            .rename(columns={"value": "deflator"})
-        )
-
-        return df

pydeflate/get_data/deflate_data.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-
-import pandas as pd
-
-
-@dataclass
-class Data(ABC):
-    _data: pd.DataFrame | None = None
-    _available_methods: dict | None = None
-    """Abstract class defining the basic structure and functionality of Data classes.
-    
-    Data classes store the price data from different sources.
-    """
-
-    @abstractmethod
-    def update(self, **kwargs) -> None:
-        """Update underlying data"""
-
-    @abstractmethod
-    def load_data(self, **kwargs) -> None:
-        """Load required data to construct deflator"""
-
-    def available_methods(self) -> dict:
-        """Return a dictionary of available methods with their functions"""
-        return self._available_methods
-
-    def get_method(self, method: str) -> pd.DataFrame:
-        """Return the data for a given method"""
-        if self._data is None:
-            self.load_data()
-
-        if method not in self._data.indicator.unique():
-            raise ValueError(f"Invalid method {method=}")
-
-        return (
-            self._data.loc[lambda d: d.indicator == method]
-            .filter(["iso_code", "year", "value"], axis=1)
-            .sort_values(["iso_code", "year"])
-            .reset_index(drop=True)
-        )
-
-    def get_deflator(self, base_year: int, method: str | None = None) -> pd.DataFrame:
-        if method is None:
-            raise ValueError("method must be specified")
-
-        if method not in self.available_methods():
-            raise ValueError(f"method must be one of {self.available_methods().keys()}")
-
-        if self._data is None:
-            self.load_data()
-
-        d_ = self.get_method(self._available_methods[method])
-
-        # get the data for the selected base year.
-        d_base = d_.query(f"year.dt.year == {base_year}")
-
-        # If base year is not valid, raise error
-        if len(d_base) == 0:
-            raise ValueError(f"No currency exchange data for {base_year=}")
-
-        # Merge the exchange data and the base year data
-        d_ = d_.merge(d_base, how="left", on=["iso_code"], suffixes=("", "_base"))
-
-        # Calculate the deflator
-        d_.value = round(100 * d_.value / d_.value_base, 6)
-
-        return d_.filter(["iso_code", "year", "value"], axis=1)

pydeflate/get_data/exchange_data.py

@@ -1,371 +0,0 @@
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-
-import pandas as pd
-
-from pydeflate.get_data.imf_data import IMF
-from pydeflate.get_data.wb_data import END, START, update_world_bank_data
-from pydeflate.pydeflate_config import PYDEFLATE_PATHS, logger
-from pydeflate.utils import emu
-
-
-def _exchange_ratio(source_xe: pd.DataFrame, target_xe: pd.DataFrame) -> pd.DataFrame:
-    return (
-        source_xe.merge(
-            target_xe,
-            how="left",
-            on=["year", "iso_code"],
-            suffixes=("_source", "_target"),
-        )
-        .assign(value=lambda d: d.value_source / d.value_target)
-        .drop(["value_source", "value_target"], axis=1)
-    )
-
-
-def _calculate_deflator(xe: pd.DataFrame, base_year: int) -> pd.DataFrame:
-    # get the data for the selected base year.
-    xe_base = xe.query(f"year.dt.year == {base_year}")
-
-    # If base year is not valid, raise error
-    if len(xe_base) == 0:
-        raise ValueError(f"No currency exchange data for {base_year=}")
-
-    # Merge the exchange data and the base year data
-    xe = xe.merge(xe_base, how="left", on=["iso_code"], suffixes=("", "_base"))
-
-    # Calculate the deflator
-    xe.value = round(100 * xe.value / xe.value_base, 6)
-
-    return xe.filter(["iso_code", "year", "value"], axis=1)
-
-
-@dataclass
-class Exchange(ABC):
-    """An abstract class to update, load and return exchange rate data.
-
-    Attributes:
-        method: the method to use to calculate the exchange rate.
-
-    """
-
-    method: str | None
-    _data: pd.DataFrame | None = None
-
-    @abstractmethod
-    def update(self, **kwargs) -> None:
-        """Update underlying data"""
-
-    @abstractmethod
-    def load_data(self, **kwargs) -> None:
-        """Load required data to construct deflator"""
-
-    @abstractmethod
-    def usd_exchange_rate(self, direction: str = "lcu_to_uds") -> pd.DataFrame:
-        """Get the exchange rate of a currency to USD (or vice versa)
-
-        Args:
-            direction: the direction of the exchange rate. Either "lcu_to_usd"
-            or "usd_to_lcu".
-
-        Returns:
-            A dataframe with the exchange rate of the currency to USD (or vice versa).
-        """
-
-    def exchange_rate(self, currency_iso: str) -> pd.DataFrame:
-        """Get an exchange rate for a given ISO
-
-        Args:
-            currency_iso: the iso_code of the currency to get the exchange rate for.
-
-        Returns:
-            A dataframe with the exchange rate for the specified currency.
-        """
-
-        # get usd exchange rates
-        d_ = self.usd_exchange_rate()
-
-        # filter the exchange rate of the chosen currency
-        target_iso = d_.query(f"iso_code == '{currency_iso}'")
-
-        # If currency is not valid, raise error
-        if len(target_iso) == 0:
-            raise ValueError(f"No currency exchange data for {currency_iso=}")
-
-        # merge the two datasets and calculate new exchange rate
-        return (
-            pd.merge(d_, target_iso, how="left", on=["year"], suffixes=("", "_xe"))
-            .assign(value=lambda d: d.value / d.value_xe)
-            .drop(columns=["value_xe", "iso_code_xe"])
-        )
-
-    def exchange_deflator(
-        self, source_iso: str, target_iso: str, base_year: int
-    ) -> pd.DataFrame:
-        """Get an exchange rate deflator for a given ISO
-
-        Args:
-            source_iso: the iso_code in which the "original" data is based.
-                The default should be "LCU".
-            target_iso: the iso_code of the currency to get the exchange rate for.
-            base_year: the base year to calculate the deflator.
-
-        Returns:
-            A dataframe with the exchange rate deflator for the specified currency.
-
-        """
-        # Get exchange data based on the source currency. If LCU set to None
-        source_xe = (
-            self.exchange_rate(currency_iso=source_iso)
-            if source_iso != "LCU"
-            else self.exchange_rate(currency_iso="USA").assign(value=1)
-        )
-
-        # Get exchange data based on the target currency. If LCU set to None
-        target_xe = (
-            self.exchange_rate(currency_iso=target_iso)
-            if target_iso != "LCU"
-            else self.exchange_rate(currency_iso="USA").assign(value=1)
-        )
-
-        # calculate conversion ratio
-        exchange_ratio = _exchange_ratio(source_xe=source_xe, target_xe=target_xe)
-
-        # get the data for the selected base year.
-        if target_iso != "LCU":
-            xe = self.exchange_rate(currency_iso=target_iso)
-        elif source_iso != "LCU":
-            xe = self.exchange_rate(currency_iso=source_iso)
-        else:
-            xe = self.exchange_rate(currency_iso="USA").assign(value=1)
-
-        # Calculate the deflator
-        xe = _calculate_deflator(xe=xe, base_year=base_year)
-
-        # Merge the conversion ratio
-        xe = xe.merge(
-            exchange_ratio,
-            how="left",
-            on=["year", "iso_code"],
-            suffixes=("_xe", "_xe_ratio"),
-        )
-
-        # Convert deflators to currency of interest
-        xe = xe.assign(value=lambda d: d.value_xe * d.value_xe_ratio)
-
-        return xe.filter(["year", "iso_code", "value"], axis=1)
-
-
-@dataclass
-class ExchangeOECD(Exchange):
-    """The OECD exchange rate data
-
-    Attributes:
-        method: the method to use to calculate the exchange rate. For this source,
-        the only valid method is “implied”.
-    """
-
-    method: str = "implied"
-    _load_try_count: int = 0
-
-    @staticmethod
-    def update(**kwargs) -> None:
-        """Update the DAC1 data, which is the source for the OECD exchange rates."""
-        from pydeflate.get_data import oecd_data
-
-        oecd_data.update_dac1()
-
-    def load_data(self, **kwargs) -> None:
-        """Load the OECD DAC price deflators data.
-
-        If the data is not found, it will be downloaded.
-        DAC deflators are transformed into price deflators by using the
-        implied exchange rate information from the OECD DAC data.
-
-        The deflators that are loaded is therefore *not* the DAC deflator,
-        but the price deflator used to produce the DAC deflators.
-
-        """
-        try:
-            self._data = pd.read_feather(
-                PYDEFLATE_PATHS.data / "pydeflate_dac1.feather"
-            )
-        except FileNotFoundError:
-            logger.info("Data not found, downloading...")
-            self.update()
-            self.load_data()
-            return
-
-    def usd_exchange_rate(self, direction: str = "lcu_usd") -> pd.DataFrame:
-        """Get the exchange rate of a currency to USD (or vice versa)
-
-        Args:
-            direction: the direction of the exchange rate. Either "lcu_to_usd"
-            or "usd_to_lcu".
-
-        Returns:
-            A dataframe with the exchange rate of the currency to USD (or vice versa).
-        """
-
-        # If data is not loaded, load it
-        if self._data is None:
-            self.load_data()
-
-        # Filter the data to only include the required columns, rename the value column.
-        d_ = self._data[["iso_code", "year", "exchange"]].rename(
-            columns={"exchange": "value"}
-        )
-
-        # if the direction is lcu to usd, return the data
-        if direction == "lcu_usd":
-            return d_
-        # if the direction is usd to lcu, invert the exchange rate.
-        elif direction == "usd_lcu":
-            d_.value = 1 / d_.value
-            return d_
-        # if the direction is not valid, raise error
-        else:
-            raise ValueError("Direction must be 'lcu_usd' or 'usd_lcu'")
-
-
-@dataclass
-class ExchangeWorldBank(Exchange):
-    """The World Bank exchange rate data
-
-    Attributes:
-        method: the method to use to calculate the exchange rate. For this source,
-        the valid methods are "yearly_average" and "effective_exchange".
-    """
-
-    method: str = "yearly_average"
-    _load_try_count: int = 0
-
-    def __post_init__(self):
-        """Check that the method is valid"""
-        if self.method not in ["yearly_average", "effective_exchange"]:
-            raise ValueError("Method must be 'yearly_average' or 'effective_exchange'")
-
-    def update(self) -> None:
-        """Update the World Bank data"""
-        update_world_bank_data()
-
-    def load_data(self, **kwargs) -> None:
-        """Load the World Bank data"""
-        # method mapping
-        method_map = {
-            "yearly_average": "PA.NUS.FCRF",
-            "effective_exchange": "PX.REX.REER",
-        }
-
-        if self._load_try_count < 1:
-            # Try to load the data from disk
-            try:
-                self._data = (
-                    pd.read_csv(
-                        PYDEFLATE_PATHS.data
-                        / f"{method_map[self.method]}_{START}-{END}_.csv",
-                        parse_dates=["date"],
-                    )
-                    .rename(columns={"date": "year"})
-                    .drop(columns=["indicator_code"])
-                )
-
-            # If the data is not found, download it. Reload the data to the object.
-            except FileNotFoundError:
-                logger.info("World Bank data not found, downloading...")
-                self._load_try_count = +1
-                self.update()
-                self.load_data()
-        else:
-            raise FileNotFoundError("Could not load World Bank data")
-
-    def usd_exchange_rate(self, direction: str = "lcu_usd") -> pd.DataFrame:
-        """Get the exchange rate of a currency to USD (or vice versa)
-
-        Args:
-            direction: the direction of the exchange rate. Either "lcu_to_usd"
-            or "usd_to_lcu".
-
-        Returns:
-            A dataframe with the exchange rate of the currency to USD (or vice versa).
-
-        """
-
-        if direction not in ["lcu_usd", "usd_lcu"]:
-            raise ValueError("Direction must be 'lcu_usd' or 'usd_lcu'")
-
-        # If data is not loaded, load it
-        if self._data is None:
-            self.load_data()
-
-        # Load the data into a temporary variable
-        df = self._data.copy(deep=True)
-
-        # Find the "Euro" data. This is done given that some countries are missing
-        # exchange rates, but they are part of the Euro area.
-        eur = df.loc[df.iso_code == "EMU"].dropna().set_index("year")["value"].to_dict()
-
-        # Euro area countries without exchange rates
-        eur_mask = (df.iso_code.isin(emu())) & (df.value.isna())
-
-        # Assign EURO exchange rate to euro are countries from year euro adopted
-        df.loc[eur_mask, "value"] = df.year.map(eur)
-
-        # If the direction is lcu to usd, return the data
-
-        if direction == "lcu_usd":
-            return df
-        # if the direction is usd to lcu, invert the exchange rate.
-
-        df.value = 1 / df.value
-        return df
-
-
-@dataclass
-class ExchangeIMF(Exchange):
-    """The IMF exchange rate data
-
-    Attributes:
-        method: the method to use to calculate the exchange rate. For this source,
-        the only valid method is “implied”.
-
-    """
-
-    method: str = "implied"
-    _imf: IMF | None = None
-
-    def __post_init__(self):
-        """Load an IMF object to manage getting the data"""
-        if self._imf is None:
-            self._imf = IMF()
-
-    def update(self, **kwargs) -> None:
-        """Update the IMF data"""
-        self._imf.update()
-
-    def load_data(self, **kwargs) -> None:
-        """Load the IMF data"""
-
-        # if no direction is passed, default to lcu to usd
-        direction = "lcu_usd" if "direction" not in kwargs else kwargs["direction"]
-        self._data = self._imf.implied_exchange(direction=direction)
-
-    def usd_exchange_rate(self, direction: str = "lcu_usd") -> pd.DataFrame:
-        """Get the exchange rate of a currency to USD (or vice versa)
-
-        Args:
-            direction: the direction of the exchange rate. Either "lcu_to_usd"
-            or "usd_to_lcu".
-
-        Returns:
-            A dataframe with the exchange rate of the currency to USD (or vice versa).
-
-        """
-
-        if direction not in ["lcu_usd", "usd_lcu"]:
-            raise ValueError("Direction must be 'lcu_usd' or 'usd_lcu'")
-
-        # load the data
-        self.load_data(direction=direction)
-
-        # return the data
-        return self._data

pydeflate/get_data/imf_data.py

@@ -1,76 +0,0 @@
-from dataclasses import dataclass
-
-import pandas as pd
-from bblocks import WorldEconomicOutlook, set_bblocks_data_path
-
-from pydeflate.get_data.deflate_data import Data
-from pydeflate.pydeflate_config import PYDEFLATE_PATHS
-from pydeflate.tools.update_data import update_update_date
-
-set_bblocks_data_path(PYDEFLATE_PATHS.data)
-
-
-@dataclass
-class IMF(Data):
-    _weo: WorldEconomicOutlook = None
-    """An object to download and return the latest IMF WEO data for several indicators"""
-
-    def __post_init__(self):
-        self._weo = WorldEconomicOutlook()
-        self._available_methods = {
-            "Consumer price index": "PCPI",
-            "Consumer price index, end of period": "PCPIE",
-            "Gross domestic product, deflator": "NGDP_D",
-            "gdp": "NGDP_D",
-            "pcpi": "PCPI",
-            "pcpie": "PCPIE",
-        }
-
-    def update(self) -> None:
-        """Update the stored WEO data, using WEO package."""
-        self._weo.update_data(reload_data=False, year=None, release=None)
-        update_update_date(source="IMF")
-
-    def load_data(
-        self, latest_y: int | None = None, latest_r: int | None = None
-    ) -> None:
-        """Loading WEO as a clean dataframe
-
-        Args:
-            latest_y: passed only optional to override the behaviour to get the latest
-            release year for the WEO.
-            latest_r: passed only optionally to override the behaviour to get the latest
-            released value (1 or 2).
-        """
-        # load the data for available indicators
-        indicators = list(self._available_methods.values()) + ["NGDP", "NGDPD"]
-        self._weo.load_data(indicators)
-
-        # get the data into a dataframe
-        self._data = self._weo.get_data(keep_metadata=False)
-
-    def implied_exchange(self, direction: str = "lcu_usd") -> pd.DataFrame:
-        """Get the implied exchange rate used by the IMF
-        Args:
-            direction: the direction of the exchange rate, either lcu_usd for
-            local currency units per usd, or usd_lcu for the opposite.
-        """
-
-        # USD data
-        usd = self.get_method("NGDPD")
-
-        # LCU data
-        lcu = self.get_method("NGDP")
-
-        # Merge datasets
-        d_ = usd.merge(lcu, on=["iso_code", "year"], suffixes=("_usd", "_lcu"))
-
-        # Calculate implied exchange rate
-        if direction == "lcu_usd":
-            d_["value"] = d_["value_lcu"] / d_["value_usd"]
-        elif direction == "usd_lcu":
-            d_["value"] = d_["value_usd"] / d_["value_lcu"]
-        else:
-            raise ValueError(f"direction must be lcu_usd or usd_lcu, not {direction}")
-
-        return d_.filter(["iso_code", "year", "value"], axis=1)