hdx-python-country 3.9.1__tar.gz → 3.9.2__tar.gz

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hdx-python-country
-Version: 3.9.1
+Version: 3.9.2
 Summary: HDX Python country code and exchange rate (fx) utilities
 Project-URL: Homepage, https://github.com/OCHA-DAP/hdx-python-country
 Author: Michael Rans

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/documentation/index.md

@@ -42,6 +42,8 @@ The code for the library is [here](https://github.com/OCHA-DAP/hdx-python-countr
 The library has detailed API documentation which can be found in the menu at the top.
 
 ## Breaking Changes
+From 3.9.2, must call Currency.setup before using Currency methods.
+
 From 3.7.5, removed clean_name function. There is now a function normalise in
 HDX Python Utilities.
 
@@ -191,9 +193,11 @@ AdminLevel objects in a list or lists of p-codes per parent admin level:
 
 ## Currencies
 
-Various functions support the conversion of monetary amounts to USD. Note that the
-returned values are cached to reduce network usage which means that the library is
-unsuited for use where rates are expected to update while the program is running:
+Various functions support the conversion of monetary amounts to USD. The setup
+method must be called once before using any other methods. Note that the
+returned values are cached to reduce network usage which means that the
+library is unsuited for use where rates are expected to update while the
+program is running:
 
     Currency.setup(fallback_historic_to_current=True, fallback_current_to_static=True, log_level=logging.INFO)
     currency = Country.get_currency_from_iso3("usa")  # returns "USD"

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/requirements.txt

@@ -42,7 +42,7 @@ ghp-import==2.1.0
     # via mkdocs
 hdx-python-utilities==3.8.5
     # via hdx-python-country (pyproject.toml)
-humanize==4.12.1
+humanize==4.12.2
     # via frictionless
 identify==2.6.9
     # via pre-commit

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/src/hdx/location/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.9.1'
-__version_tuple__ = version_tuple = (3, 9, 1)
+__version__ = version = '3.9.2'
+__version_tuple__ = version_tuple = (3, 9, 2)

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/src/hdx/location/currency.py

@@ -1,7 +1,7 @@
 """Currency conversion"""
 
 import logging
-from copy import copy
+from copy import deepcopy
 from datetime import datetime, timezone
 from typing import Dict, Optional, Union
 
@@ -33,11 +33,11 @@ class Currency:
     _secondary_historic_url = (
         "https://codeforiati.org/imf-exchangerates/imf_exchangerates.csv"
     )
-    _cached_current_rates = None
-    _cached_historic_rates = None
-    _rates_api = None
-    _secondary_rates = None
-    _secondary_historic = None
+    _cached_current_rates = {}
+    _cached_historic_rates = {}
+    _rates_api = ""
+    _secondary_rates = {}
+    _secondary_historic_rates = {}
     _fallback_to_current = False
     _no_historic = False
     _user_agent = "hdx-python-country-rates"
@@ -52,7 +52,8 @@ class Currency:
         retriever: Optional[Retrieve] = None,
         primary_rates_url: str = _primary_rates_url,
         secondary_rates_url: str = _secondary_rates_url,
-        secondary_historic_url: str = _secondary_historic_url,
+        secondary_historic_url: Optional[str] = _secondary_historic_url,
+        secondary_historic_rates: Optional[Dict] = None,
         fallback_historic_to_current: bool = False,
         fallback_current_to_static: bool = False,
         no_historic: bool = False,
@@ -60,6 +61,7 @@ class Currency:
         log_level: int = logging.DEBUG,
         current_rates_cache: Dict = {"USD": 1},
         historic_rates_cache: Dict = {},
+        use_secondary_historic: bool = False,
     ) -> None:
         """
         Setup the sources. If you wish to use a static fallback file by setting
@@ -70,7 +72,8 @@ class Currency:
             retriever (Optional[Retrieve]): Retrieve object to use for downloading. Defaults to None (generate a new one).
             primary_rates_url (str): Primary rates url to use. Defaults to Yahoo API.
             secondary_rates_url (str): Current rates url to use. Defaults to currency-api.
-            secondary_historic_url (str): Historic rates url to use. Defaults to IMF (via IATI).
+            secondary_historic_url (Optional[str]): Historic rates url to use. Defaults to IMF (via IATI).
+            secondary_historic_rates (Optional[Dict]): Historic rates to use. Defaults to None.
             fallback_historic_to_current (bool): If historic unavailable, fallback to current. Defaults to False.
             fallback_current_to_static (bool): Use static file as final fallback. Defaults to False.
             no_historic (bool): Do not set up historic rates. Defaults to False.
@@ -78,16 +81,20 @@ class Currency:
             log_level (int): Level at which to log messages. Defaults to logging.DEBUG.
             current_rates_cache (Dict): Pre-populate current rates cache with given values. Defaults to {"USD": 1}.
             historic_rates_cache (Dict): Pre-populate historic rates cache with given values. Defaults to {}.
+            use_secondary_historic (bool): Use secondary historic first. Defaults to False.
 
         Returns:
             None
         """
 
-        cls._cached_current_rates = copy(current_rates_cache)
-        cls._cached_historic_rates = copy(historic_rates_cache)
+        cls._cached_current_rates = deepcopy(current_rates_cache)
+        cls._cached_historic_rates = deepcopy(historic_rates_cache)
         cls._rates_api = primary_rates_url
-        cls._secondary_rates = None
-        cls._secondary_historic = None
+        cls._secondary_rates = {}
+        if secondary_historic_rates is not None:
+            cls._secondary_historic_rates = secondary_historic_rates
+        else:
+            cls._secondary_historic_rates = {}
         if retriever is None:
             downloader = Download(user_agent=cls._user_agent)
             temp_dir = get_temp_dir(cls._user_agent)
@@ -110,30 +117,33 @@ class Currency:
             cls._secondary_rates = secondary_rates["usd"]
         except (DownloadError, OSError):
             logger.exception("Error getting secondary current rates!")
-            cls._secondary_rates = "FAIL"
         cls._fixed_now = fixed_now
         cls._log_level = log_level
         if no_historic:
-            cls._no_historic = True
-        if cls._no_historic:
             return
-        try:
-            _, iterator = retriever.get_tabular_rows(
-                secondary_historic_url,
-                dict_form=True,
-                filename="historic_rates.csv",
-                logstr="secondary historic exchange rates",
-            )
-            cls._secondary_historic = {}
-            for row in iterator:
-                currency = row["Currency"]
-                date = get_int_timestamp(parse_date(row["Date"]))
-                rate = float(row["Rate"])
-                dict_of_dicts_add(cls._secondary_historic, currency, date, rate)
-        except (DownloadError, OSError):
-            logger.exception("Error getting secondary historic rates!")
-            cls._secondary_historic = "FAIL"
+        cls._no_historic = no_historic
+        if secondary_historic_url:
+            try:
+                _, iterator = retriever.get_tabular_rows(
+                    secondary_historic_url,
+                    dict_form=True,
+                    filename="historic_rates.csv",
+                    logstr="secondary historic exchange rates",
+                )
+                for row in iterator:
+                    currency = row["Currency"]
+                    date = get_int_timestamp(parse_date(row["Date"]))
+                    rate = float(row["Rate"])
+                    dict_of_dicts_add(
+                        cls._secondary_historic_rates, currency, date, rate
+                    )
+            except (DownloadError, OSError):
+                logger.exception("Error getting secondary historic rates!")
         cls._fallback_to_current = fallback_historic_to_current
+        if use_secondary_historic:
+            cls._get_historic_rate = cls._get_historic_rate_secondary
+        else:
+            cls._get_historic_rate = cls._get_historic_rate_primary
 
     @classmethod
     def _get_primary_rates_data(
@@ -149,8 +159,8 @@ class Currency:
         Returns:
             Optional[float]: fx rate or None
         """
-        if cls._rates_api is None:
-            Currency.setup()
+        if not cls._rates_api:
+            return None
         url = cls._rates_api.format(currency=currency, date=str(timestamp))
         if downloader is None:
             downloader = cls._retriever
@@ -289,10 +299,6 @@ class Currency:
         Returns:
             Optional[float]: fx rate or None
         """
-        if cls._secondary_rates is None:
-            Currency.setup()
-        if cls._secondary_rates == "FAIL":
-            return None
         return cls._secondary_rates.get(currency.lower())
 
     @classmethod
@@ -307,8 +313,6 @@ class Currency:
             float: fx rate
         """
         currency = currency.upper()
-        if cls._cached_current_rates is None:
-            Currency.setup()
         fx_rate = cls._cached_current_rates.get(currency)
         if fx_rate is not None:
             return fx_rate
@@ -361,39 +365,13 @@ class Currency:
         fx_rate = cls.get_current_rate(currency)
         return usdvalue * fx_rate
 
-    @classmethod
-    def _get_interpolated_rate(
-        cls,
-        timestamp1: int,
-        rate1: float,
-        timestamp2: int,
-        rate2: float,
-        desired_timestamp: int,
-    ) -> float:
-        """
-        Return a rate for a desired timestamp based on linearly interpolating between
-        two timestamp/rate pairs.
-
-        Args:
-            timestamp1 (int): First timestamp to use for fx conversion
-            rate1 (float): Rate at first timestamp
-            timestamp2 (int): Second timestamp to use for fx conversion
-            rate2 (float): Rate at second timestamp
-            desired_timestamp (int): Timestamp at which rate is desired
-
-        Returns:
-            float: Rate at desired timestamp
-        """
-        return rate1 + (desired_timestamp - timestamp1) * (
-            (rate2 - rate1) / (timestamp2 - timestamp1)
-        )
-
     @classmethod
     def _get_secondary_historic_rate(
         cls, currency: str, timestamp: int
     ) -> Optional[float]:
         """
-        Get the secondary fx rate for currency on a particular date
+        Get the historic fx rate for currency on a particular date using
+        interpolation if needed.
 
         Args:
             currency (str): Currency
@@ -402,11 +380,7 @@ class Currency:
         Returns:
             Optional[float]: fx rate or None
         """
-        if cls._secondary_historic is None:
-            Currency.setup()
-        if cls._secondary_historic == "FAIL":
-            return None
-        currency_data = cls._secondary_historic.get(currency)
+        currency_data = cls._secondary_historic_rates.get(currency)
         if currency_data is None:
             return None
         fx_rate = currency_data.get(timestamp)
@@ -426,14 +400,67 @@ class Currency:
             return currency_data[timestamp2]
         if timestamp2 is None:
             return currency_data[timestamp1]
-        return cls._get_interpolated_rate(
-            timestamp1,
-            currency_data[timestamp1],
-            timestamp2,
-            currency_data[timestamp2],
-            timestamp,
+        rate1 = currency_data[timestamp1]
+        return rate1 + (timestamp - timestamp1) * (
+            (currency_data[timestamp2] - rate1) / (timestamp2 - timestamp1)
         )
 
+    @classmethod
+    def _get_historic_rate_primary(cls, currency: str, timestamp: int) -> float:
+        currency_data = cls._cached_historic_rates.get(currency)
+        if currency_data is not None:
+            fx_rate = currency_data.get(timestamp)
+            if fx_rate is not None:
+                return fx_rate
+        fx_rate = cls._get_primary_rate(currency, timestamp)
+        if fx_rate is not None:
+            dict_of_dicts_add(cls._cached_historic_rates, currency, timestamp, fx_rate)
+            return fx_rate
+        fx_rate = cls._get_secondary_historic_rate(currency, timestamp)
+        if fx_rate is not None:
+            dict_of_dicts_add(cls._cached_historic_rates, currency, timestamp, fx_rate)
+            return fx_rate
+        if cls._fallback_to_current:
+            fx_rate = cls.get_current_rate(currency)
+            if fx_rate:
+                logger.debug(
+                    f"Falling back to current rate for currency {currency} on timestamp {timestamp}!"
+                )
+            return fx_rate
+        raise CurrencyError(
+            f"Failed to get rate for currency {currency} on timestamp {timestamp}!"
+        )
+
+    @classmethod
+    def _get_historic_rate_secondary(cls, currency: str, timestamp: int) -> float:
+        currency_data = cls._cached_historic_rates.get(currency)
+        if currency_data is not None:
+            fx_rate = currency_data.get(timestamp)
+            if fx_rate is not None:
+                return fx_rate
+        fx_rate = cls._get_secondary_historic_rate(currency, timestamp)
+        if fx_rate is None:
+            fx_rate = cls._get_primary_rate(currency, timestamp)
+            if fx_rate is None:
+                if cls._fallback_to_current:
+                    fx_rate = cls.get_current_rate(currency)
+                    if fx_rate:
+                        logger.debug(
+                            f"Falling back to current rate for currency {currency} on timestamp {timestamp}!"
+                        )
+                    return fx_rate
+                raise CurrencyError(
+                    f"Failed to get rate for currency {currency} on timestamp {timestamp}!"
+                )
+            else:
+                dict_of_dicts_add(
+                    cls._cached_historic_rates, currency, timestamp, fx_rate
+                )
+                return fx_rate
+        else:
+            dict_of_dicts_add(cls._cached_historic_rates, currency, timestamp, fx_rate)
+            return fx_rate
+
     @classmethod
     def get_historic_rate(
         cls, currency: str, date: datetime, ignore_timeinfo: bool = True
@@ -455,38 +482,12 @@ class Currency:
         currency = currency.upper()
         if currency == "USD":
             return 1
-        if cls._cached_historic_rates is None:
-            Currency.setup()
-        currency_data = cls._cached_historic_rates.get(currency)
         if ignore_timeinfo:
             date = date.replace(
                 hour=0, minute=0, second=0, microsecond=0, tzinfo=timezone.utc
             )
-        else:
-            date = date.astimezone(timezone.utc)
         timestamp = get_int_timestamp(date)
-        if currency_data is not None:
-            fx_rate = currency_data.get(timestamp)
-            if fx_rate is not None:
-                return fx_rate
-        fx_rate = cls._get_primary_rate(currency, timestamp)
-        if fx_rate is not None:
-            dict_of_dicts_add(cls._cached_historic_rates, currency, timestamp, fx_rate)
-            return fx_rate
-        fx_rate = cls._get_secondary_historic_rate(currency, timestamp)
-        if fx_rate is not None:
-            dict_of_dicts_add(cls._cached_historic_rates, currency, timestamp, fx_rate)
-            return fx_rate
-        if cls._fallback_to_current:
-            fx_rate = cls.get_current_rate(currency)
-            if fx_rate:
-                logger.debug(
-                    f"Falling back to current rate for currency {currency} on date {date.isoformat()}!"
-                )
-            return fx_rate
-        raise CurrencyError(
-            f"Failed to get rate for currency {currency} on date {date.isoformat()}!"
-        )
+        return cls._get_historic_rate(currency, timestamp)
 
     @classmethod
     def get_historic_value_in_usd(

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/src/hdx/location/wfp_exchangerates.py

@@ -58,7 +58,7 @@ class WFPExchangeRates:
             parameters={"currencyName": currency},
         )
         historic_rates = {}
-        for quote in quotes:
+        for quote in reversed(quotes):
             if not quote["isOfficial"]:
                 continue
             date = parse_date(quote["date"])

hdx_python_country-3.9.2/tests/hdx/location/conftest.py

@@ -0,0 +1,26 @@
+from os.path import join
+
+import pytest
+
+from hdx.location.currency import Currency
+
+
+@pytest.fixture(scope="session")
+def fixtures_dir():
+    return join("tests", "fixtures")
+
+
+@pytest.fixture(scope="session")
+def input_dir(fixtures_dir):
+    return join(fixtures_dir, "wfp")
+
+
+@pytest.fixture(scope="function")
+def reset_currency():
+    Currency._cached_current_rates = {}
+    Currency._cached_historic_rates = {}
+    Currency._rates_api = ""
+    Currency._secondary_rates = {}
+    Currency._secondary_historic_rates = {}
+    Currency._fallback_to_current = False
+    Currency._no_historic = False

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/tests/hdx/location/test_adminlevel.py

@@ -13,10 +13,6 @@ from hdx.utilities.retriever import Retrieve
 
 
 class TestAdminLevel:
-    @pytest.fixture(scope="class")
-    def fixtures_dir(self):
-        return join("tests", "fixtures")
-
     @pytest.fixture(scope="function")
     def config(self, fixtures_dir):
         return load_yaml(join(fixtures_dir, "adminlevel.yaml"))

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/tests/hdx/location/test_currency.py

@@ -15,23 +15,19 @@ from hdx.utilities.useragent import UserAgent
 
 class TestCurrency:
     @pytest.fixture(scope="class")
-    def fixtures(self):
-        return join("tests", "fixtures")
+    def secondary_rates_url(self, fixtures_dir):
+        return join(fixtures_dir, "secondary_rates.json")
 
     @pytest.fixture(scope="class")
-    def secondary_rates_url(self, fixtures):
-        return join(fixtures, "secondary_rates.json")
-
-    @pytest.fixture(scope="class")
-    def secondary_historic_url(self, fixtures):
-        return join(fixtures, "secondary_historic_rates.csv")
+    def secondary_historic_url(self, fixtures_dir):
+        return join(fixtures_dir, "secondary_historic_rates.csv")
 
     @pytest.fixture(scope="class", autouse=True)
-    def retrievers(self, fixtures):
+    def retrievers(self, fixtures_dir):
         name = "hdx-python-country-rates"
         UserAgent.set_global(name)
         downloader = Download()
-        fallback_dir = fixtures
+        fallback_dir = fixtures_dir
         temp_dir = get_temp_dir(name)
         retriever = Retrieve(
             downloader,
@@ -52,7 +48,9 @@ class TestCurrency:
         yield retriever, retriever_broken
         UserAgent.clear_global()
 
-    def test_get_current_value_in_usd(self, retrievers, secondary_rates_url):
+    def test_get_current_value_in_usd(
+        self, reset_currency, retrievers, secondary_rates_url
+    ):
         Currency.setup(no_historic=True)
         assert Currency.get_current_value_in_usd(10, "usd") == 10
         assert Currency.get_current_value_in_currency(10, "usd") == 10
@@ -106,6 +104,9 @@ class TestCurrency:
             )
             Currency.get_current_value_in_currency(10, "gbp")
         Currency._rates_api = None
+        with pytest.raises(CurrencyError):
+            Currency.get_current_rate("gbp")
+        Currency._rates_api = Currency._primary_rates_url
         assert Currency.get_current_rate("usd") == 1
         rate1gbp = Currency.get_current_rate("gbp")
         assert rate1gbp != 1
@@ -114,27 +115,25 @@ class TestCurrency:
         Currency.setup(
             retriever=retrievers[1],
             primary_rates_url="fail",
-            secondary_rates_url="fail",
             fallback_current_to_static=False,
             no_historic=True,
         )
-        Currency._secondary_rates = None
         rate2gbp = Currency.get_current_rate("gbp")
         assert rate2gbp != 1
         assert abs(rate1gbp - rate2gbp) / rate1gbp < 0.008
         Currency.setup(
             retriever=retrievers[1],
             primary_rates_url="fail",
-            secondary_rates_url="fail",
             fallback_current_to_static=False,
             no_historic=True,
         )
-        Currency._secondary_rates = None
         rate2xdr = Currency.get_current_rate("xdr")
         assert rate2xdr != 1
         assert abs(rate1xdr - rate2xdr) / rate1xdr < 0.1
 
-    def test_get_current_value_in_usd_fixednnow(self, retrievers, secondary_rates_url):
+    def test_get_current_value_in_usd_fixednnow(
+        self, reset_currency, retrievers, secondary_rates_url
+    ):
         date = parse_date("2020-02-20")
         Currency.setup(
             no_historic=True,
@@ -148,7 +147,9 @@ class TestCurrency:
         # falls back to secondary current rates
         assert Currency.get_current_rate("xdr") == 0.76479065
 
-    def test_get_historic_value_in_usd(self, retrievers, secondary_historic_url):
+    def test_get_historic_value_in_usd(
+        self, reset_currency, retrievers, secondary_historic_url
+    ):
         Currency._no_historic = False
         Currency.setup(secondary_historic_url=secondary_historic_url)
         date = parse_date("2020-02-20")
@@ -229,13 +230,17 @@ class TestCurrency:
                 fallback_historic_to_current=False,
             )
             Currency.get_historic_value_in_usd(10, "gbp", date)
-        Currency._secondary_historic = None
+        Currency.setup(
+            retriever=retriever,
+            primary_rates_url="fail",
+            fallback_historic_to_current=False,
+        )
         # Interpolation
         # 0.761817697025102 + (0.776276975624903 - 0.761817697025102) * 20 / 29
         # 0.761817697025102 + (0.776276975624903 - 0.761817697025102) * (1582156800-1580428800) / (1582934400 - 1580428800)
         assert Currency.get_historic_rate("gbp", date) == 0.7717896133008268
 
-    def test_broken_rates_no_secondary(self, retrievers):
+    def test_broken_rates_no_secondary(self, reset_currency, retrievers):
         Currency._no_historic = False
         Currency.setup(secondary_historic_url="fail")
         # Without the checking against high and low returned by Yahoo API, this
@@ -265,7 +270,9 @@ class TestCurrency:
             == 601.632568359375
         )
 
-    def test_broken_rates_with_secondary(self, retrievers, secondary_historic_url):
+    def test_broken_rates_with_secondary(
+        self, reset_currency, retrievers, secondary_historic_url
+    ):
         Currency._no_historic = False
         Currency.setup(secondary_historic_url=secondary_historic_url)
         # Without the checking against secondary historic rate, this

{hdx_python_country-3.9.1 → hdx_python_country-3.9.2}/tests/hdx/location/test_wfp_exchangerates.py

@@ -1,7 +1,3 @@
-from os.path import join
-
-import pytest
-
 from hdx.location.currency import Currency
 from hdx.location.int_timestamp import get_int_timestamp
 from hdx.location.wfp_api import WFPAPI
@@ -13,23 +9,7 @@ from hdx.utilities.retriever import Retrieve
 
 
 class TestWFPExchangeRates:
-    @pytest.fixture(scope="class")
-    def currency(self):
-        return "afn"
-
-    @pytest.fixture(scope="class")
-    def date(self):
-        return parse_date("2020-02-20")
-
-    @pytest.fixture(scope="class")
-    def fixtures_dir(self):
-        return join("tests", "fixtures")
-
-    @pytest.fixture(scope="class")
-    def input_dir(self, fixtures_dir):
-        return join(fixtures_dir, "wfp")
-
-    def test_wfp_exchangerates(self, input_dir, currency, date):
+    def test_wfp_exchangerates(self, reset_currency, input_dir):
         with temp_dir(
             "TestWFPExchangeRates",
             delete_on_success=True,
@@ -44,6 +24,8 @@ class TestWFPExchangeRates:
                     save=False,
                     use_saved=True,
                 )
+                currency = "afn"
+                date = parse_date("2020-02-20")
                 wfp_api = WFPAPI(downloader, retriever)
                 wfp_api.update_retry_params(attempts=5, wait=5)
                 wfp_fx = WFPExchangeRates(wfp_api)
@@ -55,11 +37,27 @@ class TestWFPExchangeRates:
                 currencies = wfp_fx.get_currencies()
                 assert len(currencies) == 127
 
+                Currency.setup()
                 assert Currency.get_historic_rate(currency, date) == 76.80000305175781
                 timestamp = get_int_timestamp(date)
                 historic_rates = wfp_fx.get_currency_historic_rates(currency)
+                keys = list(historic_rates.keys())
+                sorted_keys = sorted(keys)
+                assert keys == sorted_keys
                 assert historic_rates[timestamp] == 77.01
 
                 all_historic_rates = wfp_fx.get_historic_rates([currency])
-                Currency.setup(historic_rates_cache=all_historic_rates)
+                Currency.setup(
+                    historic_rates_cache=all_historic_rates,
+                    secondary_historic_rates=all_historic_rates,
+                    use_secondary_historic=True,
+                )
+                assert Currency.get_historic_rate(currency, date) == 77.01
+                date = parse_date("2020-02-21")
                 assert Currency.get_historic_rate(currency, date) == 77.01
+                date = parse_date("2020-02-20 12:00:00")
+                assert Currency.get_historic_rate(currency, date) == 77.01
+                assert (
+                    Currency.get_historic_rate(currency, date, ignore_timeinfo=False)
+                    == 77.01
+                )