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

pydeflate-2.0.0.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.1
+Name: pydeflate
+Version: 2.0.0
+Summary: Package to convert current prices figures to constant prices and vice versa
+License: MIT
+Author: Jorge Rivera
+Author-email: jorge.rivera@one.org
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: hdx-python-country (>=3.8.1,<4.0.0)
+Requires-Dist: imf-reader (>=1.1.0,<2.0.0)
+Requires-Dist: oda-reader (>=1.0.0,<2.0.0)
+Requires-Dist: pandas (>=2,<3)
+Requires-Dist: pyarrow (>14)
+Requires-Dist: wbgapi (>=1.0.12,<2.0.0)
+Description-Content-Type: text/markdown
+
+# pydeflate
+
+[![pypi](https://img.shields.io/pypi/v/pydeflate.svg)](https://pypi.python.org/pypi/pydeflate)
+[![black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Downloads](https://pepy.tech/badge/pydeflate/month)](https://pepy.tech/project/pydeflate)
+
+**pydeflate** is a Python package to:
+- Convert current price data to constant prices.
+- Convert constant price data to current prices.
+- Convert data from one currency to another (in both current and constant prices).
+
+When converting to or from constant prices, it takes into account changes in prices and exchange rates over time. This allows for accurate comparisons across years, countries, and currencies.
+
+## Important Note
+
+**pydeflate v2 has recently been released. It includes api changes which break backwards-compatibility**. While a version of the `deflate` function is still available, it is now deprecated and will be removed in future versions. Please use the new deflator functions for improved simplicity, clarity and performance.
+
+
+# Table of Contents
+
+
+- [Installation](#installation)
+
+- [Basic Usage](#basic-usage)
+  - [Setting Up pydeflate](#setting-up-pydeflate)
+  - [DataFrame Requirements](#dataframe-requirements)
+  
+- [Converting Current to Constant Prices](#converting-current-to-constant-prices)
+  - [Example](#example-convert-current-to-constant-prices)
+
+- [Available Deflator Functions](#available-deflator-functions)
+
+- [Currency Conversion](#currency-conversion)
+  - [Example](#example-currency-conversion)
+
+- [Example: Using Source-Specific Codes](#example-using-source-specific-codes)
+
+- [Data Sources and Method Options](#data-sources-and-method-options)
+  - [International Monetary Fund](#international-monetary-fund)
+  - [World Bank](#world-bank)
+  - [OECD Development Assistance Committee](#oecd-development-assistance-committee)
+  - [Sources](#sources)
+
+- [Handling Missing Data](#handling-missing-data)
+
+- [Updating Underlying Data](#updating-underlying-data)
+
+## Installation
+
+Install pydeflate using pip:
+
+```bash
+pip install pydeflate --upgrade
+```
+
+## Basic Usage
+
+### Setting Up pydeflate
+
+Before using pydeflate, you must specify where the deflator and exchange data should be saved. This only needs to be done once per script or notebook.
+
+```python
+from pydeflate import set_pydeflate_path
+
+# Specify the path where deflator and exchange data will be saved
+set_pydeflate_path("path/to/data/folder")
+```
+
+### DataFrame requirements
+You need to provide a pandas DataFrame in order to convert data with `pydeflate`. The DataFrame must have at least the following columns:
+- **An `id_column`**: you must specify its name using the `id_column` parameter. By default, it expects `ISO3` country codes. Previous versions of pydeflate used to convert data automatically, but that could inadvertently introduce errors by mis-identifying countries. You can use tools like `bblocks`, `hdx-python-country` or `country-converter` to help you add `ISO3` codes to your data. If you're working with data from the same source as the one you're using in `pydeflate`, you can also set `use_source_codes=True`. That allows you to use the same encoding as the source data (e.g., DAC codes, IMF entity codes).
+- **A `year_column`**: which can be a string, integer, or datetime. This is needed in order to match the data to the right deflator or exchange rate. By default, pydeflate assumes that the year column is named `year`. You can change this by setting the `year_column` parameter. If the optional parameter `year_format` is not set, pydeflate will try to infer the format of the year column. You can also provide a `year_format` as a string, to specify the format of your data's year column.
+- **A `value_column`**: which contains the data to be converted. By default, pydeflate assumes that the value column is named `value`. You can change this by setting the `value_column` parameter. The type of the value column must be numeric (int, float).
+
+## Converting Current to Constant Prices
+
+Pydeflate includes multiple sources and methods to deflate data. They all work in a very similar way. For this example, we will use the IMF GDP deflator and exchange rates data.
+
+### Example: Convert Current to Constant Prices
+In this example, we first import the `imf_gdp_deflate` function and create a sample DataFrame. We then convert the data to constant 2015 EUR prices using the IMF GDP deflators and exchange rates.
+
+Note that both the `source_currency` and the `target_currency` are specified using the ISO3 country codes of the country whose currency is being used. Note that either can also be specified as `LCU` which stands for 'local currency units', or the local currency for each individual country, instead applying a single currency to all values. For convenience `pydeflate` also accepts the currency codes of certain countries (like `USD` in place of `USA`, `EUR` in place of any country that uses the euro, `GBP` in place of `GBR`, etc).
+
+If the required data to perform the conversion is not available, pydeflate will download it from the source and save it in the specified data folder. If the stored data is older than 50 days, `pydeflate` will inform you and encourage you to set the `update_data` parameter to `True`.
+
+```python
+from pydeflate import imf_gdp_deflate, set_pydeflate_path
+import pandas as pd
+
+# Specify the path where deflator and exchange data will be saved
+set_pydeflate_path("path/to/data/folder")
+
+# Example data in current USD prices
+data = {
+    'iso_code': ['FRA', 'USA', 'GTM'],
+    'year': [2017, 2017, 2017],
+    'value': [50, 100, 200]
+}
+
+df = pd.DataFrame(data)
+
+# Convert to constant EUR prices (base year 2015)
+df_constant = imf_gdp_deflate(
+    data=df,
+    base_year=2015,
+    source_currency="USA",  # Data is in USD
+    target_currency="FRA",  # Convert to Euro
+    id_column="iso_code", # must be ISO3 code
+    year_column="year", # Can be string, integer or datetime
+    value_column="value", # Column to be converted
+    target_value_column="value_constant" # It could also be the same as value_column
+)
+```
+
+### Available Deflator Functions
+
+- `imf_gdp_deflate`: Uses GDP deflators and exchange rates from the IMF World Economic Outlook.
+- `imf_cpi_deflate`: Uses Consumer Price Index and exchange rates data from the IMF World Economic Outlook.
+- `imf_cpi_e_deflate`: Uses end-of-period Consumer Price Index and exchange rates data from the IMF World Economic Outlook.
+- `wb_gdp_deflate`: Uses GDP deflators and exchange rates from the World Bank.
+- `wb_gdp_linked_deflate`: Uses the World Bank’s linked GDP deflator and exchange rates data.
+- `wb_cpi_deflate`: Uses Consumer Price Index and exchange rate data from the World Bank.
+- `oecd_dac_deflate`: Uses the OECD DAC deflator series (prices and exchange rates).
+
+
+
+## Currency Conversion
+Pydeflate includes multiple sources for currency exchange. They all work in a very similar way, using yearly exchange rates. For this example, we will use the OECD DAC exchange rates.
+
+### Example: Currency Conversion
+
+```python
+from pydeflate import oecd_dac_exchange, set_pydeflate_path
+import pandas as pd
+
+# Specify the path where deflator and exchange data will be saved
+set_pydeflate_path("path/to/data/folder")
+
+# Example data in current local currency units
+data = {
+    'iso_code': ['GBR', 'CAN', 'JPN'],
+    'year': [2011, 2015, 2015],
+    'value': [100, 100, 100]
+}
+
+df = pd.DataFrame(data)
+
+# Convert from local currency (e.g GBP, CAD, JPY in this case) to Canadian Dollars
+df_can = oecd_dac_exchange(
+    data=df,
+    source_currency="LCU", # Local currency units
+    target_currency="CAN", # Convert to Canadian Dollars (can also use 'CAD')
+    id_column="iso_code", # must be ISO3 code
+    year_column="year", # Can be string, integer or datetime
+    value_column="value", # Column to be converted
+    target_value_column="value_can" # It could also be the same as value_column
+)
+```
+
+## Example: Using Source-Specific Codes
+
+If your data uses source-specific country codes (e.g., DAC codes), set use_source_codes=True and specify the appropriate id_column.
+
+```python
+from pydeflate import oecd_dac_deflate, set_pydeflate_path
+import pandas as pd
+
+
+# Specify the path where deflator and exchange data will be saved
+set_pydeflate_path("path/to/data/folder")
+
+# Example data with DAC codes
+data = {
+    'dac_code': [302, 4, 4],
+    'year': [2010, 2016, 2018],
+    'value': [100, 100, 100]
+}
+
+df = pd.DataFrame(data)
+
+# Convert using DAC deflators and DAC codes
+df_constant = oecd_dac_deflate(
+    data=df,
+    base_year=2016,
+    source_currency="USA", # Data is in USD
+    target_currency="LCU", # Convert to local currency units
+    id_column="dac_code", # DAC codes
+    use_source_codes=True,  # Use source-specific codes
+    year_column="year", # Can be string, integer or datetime
+    value_column="value", # Column to be converted
+    target_value_column="value_constant" # It could also be the same as value_column
+)
+
+```
+
+## Data Sources and Method Options
+
+Pydeflate uses data on price/gdp deflators and exchange rates from various sources. Each source offers different options for deflators and exchange rates.
+
+For all sources, Exchange rates between two non USD currency pairs are derived from
+the LCU to USD exchange rates selected.
+
+### International Monetary Fund
+The IMF provides estimates where data is not available, including for several
+years into the future. Using these price deflators, combined with the corresponding
+exchange rates, can also allow users to convert data to constant prices for future years.
+
+Deflator Functions:
+- `imf_gdp_deflate`: Uses GDP deflators.
+- `imf_cpi_deflate`: Uses Consumer Price Index data.
+- `imf_cpi_e_deflate`: Uses end-of-period Consumer Price Index data.
+
+
+Exchange Function:
+- `imf_exchange`: Uses exchange rates derived from the IMF’s data.
+
+Notes:
+- IMF data includes estimates for future years, allowing conversion to constant prices for future dates.
+- Exchange rates are derived from the IMF’s implied rates.
+
+### World Bank
+
+Deflator Functions:
+- `wb_gdp_deflate`: Uses GDP deflators.
+- `wb_gdp_linked_deflate`: Uses the World Bank’s linked GDP deflator series.
+- `wb_cpi_deflate`: Uses Consumer Price Index data.
+
+Exchange Function:
+- `wb_exchange`: Uses yearly average exchange rates.
+
+Notes:
+- The linked GDP deflator series counters breaks in series over time due to changes in base years or methodologies.
+- Exchange rates are based on IMF International Financial Statistics data
+
+### OECD Development Assistance Committee
+
+Deflator Function:
+- `oecd_dac_deflate`: Uses the DAC’s own deflator series.
+
+Exchange Function:
+- `oecd_dac_exchange`: Uses exchange rates used and published by the DAC.
+
+### Sources
+This package relies on data from the following sources:
+- OECD DAC: https://www.oecd.org/dac/
+- IMF World Economic Outlook: https://www.imf.org/en/Publications/WEO
+- World Bank DataBank: https://databank.worldbank.org/home.aspx
+
+This data is provided based on the terms and conditions set by the
+original sources.
+
+## Handling Missing Data
+
+Pydeflate relies on data from external sources. If there are missing values in the deflator or exchange rate data for certain countries or years, pydeflate will flag this in the output DataFrame. Ensure that your data aligns with the available data from the selected source.
+
+## Updating Underlying Data
+
+Pydeflate periodically updates its underlying data from the World Bank, IMF, and OECD. If the data on your system is older than 50 days, pydeflate will display a warning upon import.
+
+
+

pydeflate-2.0.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+pydeflate/.pydeflate_data/README.md,sha256=atNtUL9dD8G184YSd6juFib8TgEQBcSLogiz99APPVs,25
+pydeflate/__init__.py,sha256=i6sHAqjE6qoEc4l1Gy1w7PN6BVhR61RqVBpn3BSDrSc,975
+pydeflate/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydeflate/core/api.py,sha256=1MzGu8xLgbUWksy_IMBuK_HgyPLSFawMgLLJsNKJSok,14351
+pydeflate/core/deflator.py,sha256=Ax3dmOF3tYRZnkIfFvMMo3SOLgAJHkXSmA-OtIUZkp0,5932
+pydeflate/core/exchange.py,sha256=chPqAo_MjEcwb49GVBlTu0s8ZhFchnjtZVCYsvVp_d0,8532
+pydeflate/core/source.py,sha256=tIN9fAPhhE-6C5Ye608qTMQblm3yva7u5p1nJwepXm4,1724
+pydeflate/deflate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydeflate/deflate/deflators.py,sha256=hyLFoX46BAn5m8gTLjw-TFv3x3W6CTQmvmUvq5a_cio,7768
+pydeflate/deflate/legacy_deflate.py,sha256=9pfqsi5KeWgP1yhXeI6K7bAjUeFY-fmRxrpDB7Zu0zo,3900
+pydeflate/exchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydeflate/exchange/exchangers.py,sha256=DWHvfH7FivgPV25R3dvBuMHWA9bxlvTDQPzg062AMN0,5384
+pydeflate/pydeflate_config.py,sha256=5s4SLJf5is5XcUgJHDRx4f27pPiaVh0H2BL8w9QjW0k,1097
+pydeflate/settings/emu.json,sha256=BIvbiMUeHUtCESR3sMcBNrS028yp2YraCJdhDJGvAAo,133
+pydeflate/settings/oecd_codes.json,sha256=jAKI1EgQP4rttjoG3Z-44r1tUJrIEzPCZF5V2aboQhE,911
+pydeflate/sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydeflate/sources/common.py,sha256=Ot0AKeQx2M7juID8qvFFpiPcCJNR9UzrpYLonTcHyCQ,9630
+pydeflate/sources/dac.py,sha256=ngFiApGZ_tIQg74ogGVTIbGUA0efnF1SYwfUuqGofOQ,3791
+pydeflate/sources/imf.py,sha256=10vc8xhNJvANb7RDD1WFn9oaZ8g53yUV5LxCQCz6ImM,6337
+pydeflate/sources/world_bank.py,sha256=YxQgUUDMXlPArIfvYJTjNIAU5_I_OeUYDzc7NtTq9EA,6288
+pydeflate/utils.py,sha256=sfocGBQook3S7gvutCFovknyCv0cV37MHPJB-EMIumQ,2321
+pydeflate-2.0.0.dist-info/LICENSE,sha256=q5tm9mQxwSbV5Ivvjxs7MMqBgan6DM8I4r4irPvmqZM,1075
+pydeflate-2.0.0.dist-info/METADATA,sha256=MxV_NdB1JYX3or3k1EoMS5nDuY2dItSNHgZVCJIrq_o,12582
+pydeflate-2.0.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pydeflate-2.0.0.dist-info/RECORD,,

{pydeflate-1.4.1.dist-info → pydeflate-2.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

pydeflate/deflate/deflate.py

@@ -1,324 +0,0 @@
-import pandas as pd
-
-from pydeflate.deflate.deflator import Deflator
-from pydeflate.get_data.exchange_data import (
-    ExchangeIMF,
-    ExchangeOECD,
-    ExchangeWorldBank,
-)
-from pydeflate.get_data.imf_data import IMF
-from pydeflate.get_data.oecd_data import OECD
-from pydeflate.get_data.wb_data import WorldBank
-from pydeflate.pydeflate_config import logger
-from pydeflate.utils import check_year_as_number, oecd_codes, to_iso3
-
-ValidDeflatorSources: dict = {
-    "oecd_dac": "dac_deflator",
-    "dac": "dac_deflator",
-    "wb": "world_bank",
-    "world_bank": "world_bank",
-    "imf": "imf",
-}
-
-ValidDeflatorMethods: dict = {
-    "oecd_dac": ["dac_deflator"],
-    "world_bank": ["gdp", "gdp_linked", "cpi"],
-    "imf": ["gdp", "pcpi", "pcpie"],
-}
-
-ValidExchangeSources: dict = {
-    "oecd_dac": "oecd_dac",
-    "dac": "oecd_dac",
-    "wb": "world_bank",
-    "world_bank": "world_bank",
-    "imf": "world_bank",
-}
-
-ValidExchangeMethods: dict = {
-    "oecd_dac": ["implied"],
-    "world_bank": ["yearly_average", "effective_exchange"],
-    "imf": ["implied"],
-}
-
-ExchangeSources: dict = {
-    "oecd_dac": {
-        "implied": ExchangeOECD(method="implied"),
-    },
-    "world_bank": {
-        "yearly_average": ExchangeWorldBank(method="yearly_average"),
-        "effective_exchange": ExchangeWorldBank(method="effective_exchange"),
-    },
-    "imf": {
-        "implied": ExchangeIMF(method="implied"),
-    },
-}
-
-DeflatorSources: dict = {
-    "oecd_dac": OECD,
-    "world_bank": WorldBank,
-    "imf": IMF,
-}
-
-
-def _validate_deflator_source(deflator_source) -> str:
-    if deflator_source not in ValidDeflatorSources:
-        raise ValueError(f'"{deflator_source=}" not valid')
-    return deflator_source
-
-
-def _validate_deflator_method(deflator_source, deflator_method) -> str:
-    # Check if the method specified is part of the available deflators methods
-    if (
-        deflator_method is not None
-        and deflator_method not in ValidDeflatorMethods[deflator_source]
-    ):
-        raise ValueError(f'"{deflator_method=}" not valid')
-
-    # Default to the first method in the list of valid methods for the source
-    if deflator_method is None:
-        deflator_method = ValidDeflatorMethods[deflator_source][0]
-
-    return deflator_method
-
-
-def _validate_exchange_source(deflator_method, exchange_source) -> str:
-    # Check if the source specified is part of the available exchange source
-    if exchange_source is not None and exchange_source not in ValidExchangeSources:
-        raise ValueError(f'"{exchange_source=}" not valid')
-
-    # Default to the first source in the list of valid sources
-    if exchange_source is None:
-        exchange_source = ValidExchangeMethods[deflator_method][0]
-
-    return exchange_source
-
-
-def _validate_exchange_method(exchange_source, exchange_method) -> str:
-    # Check if the method specified is part of the available exchange methods
-
-    if (
-        exchange_method is not None
-        and exchange_method not in ValidExchangeMethods[exchange_source]
-    ):
-        raise ValueError(f'"{exchange_method=}" not valid')
-
-    # Default to the first method in the list of valid methods for the source
-    if exchange_method is None:
-        exchange_method = ValidExchangeMethods[exchange_source][0]
-
-    return exchange_method
-
-
-def _create_id_col(df: pd.DataFrame, id_type: str, id_column: str) -> pd.DataFrame:
-    """Create an id column.
-
-    By default, if a country does not have a DAC deflator, the DAC, Total deflator is used.
-    """
-
-    if id_type == "DAC":
-        df["id_"] = df[id_column].map(oecd_codes()).fillna("DAC")
-    else:
-        df = df.pipe(
-            to_iso3, codes_col=id_column, target_col="id_", src_classification=id_type
-        )
-
-    return df
-
-
-def deflate(
-    df: pd.DataFrame,
-    base_year: int,
-    deflator_source: str = None,
-    deflator_method: str | None = None,
-    exchange_source: str | None = None,
-    exchange_method: str | None = None,
-    source_currency: str = "USA",
-    target_currency: str = "USA",
-    id_column: str = "iso_code",
-    id_type: str = "ISO3",
-    date_column: str = "date",
-    source_column: str = "value",
-    target_column: str = "value",
-    to_current: bool = False,
-    method: str | None = None,
-    source: str | None = None,
-    iso_column: str | None = None,
-    source_col: str | None = None,
-    target_col: str | None = None,
-) -> pd.DataFrame:
-    """Deflate amounts to a given currency - base year combination.
-
-    Takes a DataFrame containing flows data and returns a DataFrame containing
-    the deflated amounts. It can also convert from constant to current by specifying
-    to_current as 'True'.
-
-    Args:
-        df: the DataFrame containing the flows column to be deflated. If multiple
-            columns need to be deflated, the function needs to be called multiple times.
-        base_year: If converting from current to constant, the target base year for the
-            constant figures. If converting from constant, the base year of the data.
-        deflator_source:{‘oecd_dac’, 'wb', 'imf'}
-            The source of the data used to build the deflators. The value (and
-            completeness) of the price deflators may change based on the source.
-            Additionally, the OECD DAC data is only available for DAC donors.
-        deflator_method:{'gdp', 'gdp_linked', 'cpi', 'pcpi', 'pcpie', None}
-            The method used to calculate the price deflator:
-
-            For World Bank (source == 'wb'), default is "gdp":
-
-            •'gdp': using GDP deflators.
-
-            •'gdp_linked': a GDP deflator series which has been linked to
-            produce a consistent time series to counteract breaks in series
-            over time due to changes in base years, sources or methodologies.
-
-            •'cpi': using Consumer Price Index data
-
-            For IMF (source == 'imf'), default is "gdp":
-
-            •'pcpi': Consumer Price Index data
-
-            •'pcpie': end-period Consumer Price Index (e.g. for December each year).
-
-            For OECD DAC (source == 'oecd_dac'), default is "dac_deflator":
-            •'dac_deflator': using the OECD DAC deflator
-
-        exchange_source: The source of the exchange rates. If None, the exchange rates
-        of the deflator_source will be used.
-
-        exchange_method: The method used to calculate the exchange rates. If None, the
-        default exchange method of the exchange_source will be used.
-
-        source_currency: The iso3 code of the source currency. Note that deflators for EU countries
-            are only in Euros from the year in which the Euro was adopted. To produce
-            deflators only in euros, use 'emu'.
-
-        target_currency :The iso3 code of the deflated amounts. It can be the same as the source
-            currency. In cases where they are different, the exchange rate will be
-            applied. To produce deflators only in euros, use 'emu'.
-
-        id_column: The column containing the id codes (iso3 codes, for example) of the data's
-        currency.
-
-        id_type:The classification type for the id_column. By default, ISO3 but others are possible.
-            Any options used in the Country Converter package are valid. For the OECD DAC
-            classification, use 'DAC'.
-
-        date_column:The column containing the date values. The column can contain years (int)
-            or datetime objects.
-
-        source_column:The column containing the data to be deflated.
-
-        target_column: Column where the deflated data will be stored. It can be the same as the
-            source column if a copy of the original isn't needed.
-
-        to_current: If True, amounts will be treated as in constant prices and converted to
-        current prices.
-
-        iso_column:Provided for backwards compatibility. An alias for id_column
-        source: Provided for backwards compatibility. An alias for deflator_source
-        method: Provided for backwards compatibility. An alias for deflator_method
-        source_col: Provided for backwards compatibility. An alias for source_column
-        target_col: Provided for backwards compatibility. An alias for target_column
-
-    Returns:
-        A pandas DataFrame containing the deflated data. Years for which there
-        are no deflators will be returned as null values.
-
-
-    """
-
-    # ------------------ Backwards compatibility ------------------
-
-    # Backwards compatibility: if the iso_column parameter is used, reassign it
-    if iso_column is not None:
-        id_column = iso_column
-        logger.warning("iso_column is deprecated. Use id_column instead.")
-
-    # Backwards compatibility: if the source parameter is used, reassign it
-    if deflator_source is None and source is not None:
-        deflator_source = source
-        logger.warning("source is deprecated. Use deflator_source instead.")
-
-    # Backwards compatibility: if the method parameter is used, reassign it
-    if method is not None:
-        deflator_method = method
-        logger.warning("method is deprecated. Use deflator_method instead.")
-
-    # Backwards compatibility: if the source_col parameter is used, reassign it
-    if source_col is not None:
-        source_column = source_col
-        logger.warning("source_col is deprecated. Use source_column instead.")
-
-    # Backwards compatibility: if the target_col parameter is used, reassign it
-    if target_col is not None:
-        target_column = target_col
-        logger.warning("target_col is deprecated. Use target_column instead.")
-
-    # -------------------------- Validation -----------------------------
-    deflator_source = _validate_deflator_source(deflator_source=deflator_source)
-
-    deflator_method = _validate_deflator_method(
-        deflator_source=deflator_source, deflator_method=deflator_method
-    )
-
-    exchange_source = _validate_exchange_source(
-        deflator_method=exchange_method, exchange_source=exchange_source
-    )
-
-    exchange_method = _validate_exchange_method(
-        exchange_source=exchange_source, exchange_method=exchange_method
-    )
-
-    # ----------------------------- Set up ---------------------------
-
-    # copy the dataframe to avoid modifying the original
-    df = df.copy(deep=True)
-
-    # Keep track of original columns to return data in the same order.
-    if target_column not in df.columns:
-        cols = [*df.columns, target_column]
-    else:
-        cols = df.columns
-
-    # check if date format matches
-    df, year_as_number = check_year_as_number(df=df, date_column=date_column)
-
-    # create id_column
-    df = _create_id_col(df=df, id_column=id_column, id_type=id_type)
-
-    # ----------------------------- Load deflator data ---------------------------
-    deflator = (
-        Deflator(
-            base_year=base_year,
-            exchange_obj=ExchangeSources[exchange_source][exchange_method],
-            deflator_obj=DeflatorSources[deflator_source](),
-            deflator_method=deflator_method,
-            source_currency=source_currency,
-            target_currency=target_currency,
-            to_current=to_current,
-        )
-        .get_deflator()
-        .rename(columns={"iso_code": "id_", "year": date_column})
-    )
-
-    # ----------------------------- Deflate ---------------------------
-    # Merge the original data with the deflator DataFrame
-    df = df.merge(
-        deflator,
-        on=["id_", date_column],
-        how="left",
-        suffixes=("", "_"),
-    )
-
-    # If the reverse option is used, multiply the data. Else divide.
-    df[target_column] = df[source_column] / (df.deflator / 100)
-
-    # Keep only the columns present in the original DataFrame (including order)
-    df = df.filter(cols, axis=1)
-
-    # If the year is passed as a number, convert it back to a number.
-    if year_as_number:
-        df[date_column] = df[date_column].dt.year
-
-    return df