PYield 0.28.0__tar.gz → 0.28.2__tar.gz

{pyield-0.28.0 → pyield-0.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.28.0
+Version: 0.28.2
 Summary: A Python library for analysis of fixed income instruments in Brazil
 Project-URL: Source, https://github.com/crdcj/PYield
 Author-email: Carlos Carvalho <cr.cj@outlook.com>
@@ -34,8 +34,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Python: >=3.11
 Requires-Dist: numpy>=2.0.0
-Requires-Dist: pandas[html,parquet]>=2.0.0
-Requires-Dist: python-calamine>=0.2.0
+Requires-Dist: pandas[excel,html,parquet]>=2.0.0
 Requires-Dist: requests>=2.31.0
 Description-Content-Type: text/markdown
 
@@ -180,7 +179,7 @@ LastUpdatee      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate
 2024-04-21 13:37:39       DI1F39     2039-01-03       3683 ...    <NA>        <NA>        <NA>     <NA>
 
 # Fetch historical DI Futures data from B3
->>> yd.futures(contract_code="DI1", reference_date='08-03-2024')
+>>> yd.futures(contract_code="DI1", date='08-03-2024')
 TradeDate  TickerSymbol ExpirationDate BDaysToExp ... LastRate LastAskRate LastBidRate SettlementRate
 2024-03-08       DI1J24     2024-04-01         15 ...   10.952      10.952      10.956         10.956
 2024-03-08       DI1K24     2024-05-02         37 ...   10.776      10.774      10.780         10.777
@@ -195,11 +194,11 @@ TradeDate  TickerSymbol ExpirationDate BDaysToExp ... LastRate LastAskRate LastB
 ```python
 >>> import pyield as yd
 # Fetch the SELIC target rate from the Central Bank of Brazil
->>> yd.indicator(indicator_code="SELIC_TARGET", reference_date='12-04-2024')
+>>> yd.indicator(indicator_code="SELIC_TARGET", date='12-04-2024')
 0.1075  # 10.75%
 
 # Fetch the IPCA monthly inflation rate from IBGE
->>> yd.indicator(indicator_code="IPCA_MR", reference_date='18-03-2024')
+>>> yd.indicator(indicator_code="IPCA_MR", date='18-03-2024')
 0.0016  # 0.16%
 ```
 

{pyield-0.28.0 → pyield-0.28.2}/README.md

@@ -139,7 +139,7 @@ LastUpdatee      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate
 2024-04-21 13:37:39       DI1F39     2039-01-03       3683 ...    <NA>        <NA>        <NA>     <NA>
 
 # Fetch historical DI Futures data from B3
->>> yd.futures(contract_code="DI1", reference_date='08-03-2024')
+>>> yd.futures(contract_code="DI1", date='08-03-2024')
 TradeDate  TickerSymbol ExpirationDate BDaysToExp ... LastRate LastAskRate LastBidRate SettlementRate
 2024-03-08       DI1J24     2024-04-01         15 ...   10.952      10.952      10.956         10.956
 2024-03-08       DI1K24     2024-05-02         37 ...   10.776      10.774      10.780         10.777
@@ -154,11 +154,11 @@ TradeDate  TickerSymbol ExpirationDate BDaysToExp ... LastRate LastAskRate LastB
 ```python
 >>> import pyield as yd
 # Fetch the SELIC target rate from the Central Bank of Brazil
->>> yd.indicator(indicator_code="SELIC_TARGET", reference_date='12-04-2024')
+>>> yd.indicator(indicator_code="SELIC_TARGET", date='12-04-2024')
 0.1075  # 10.75%
 
 # Fetch the IPCA monthly inflation rate from IBGE
->>> yd.indicator(indicator_code="IPCA_MR", reference_date='18-03-2024')
+>>> yd.indicator(indicator_code="IPCA_MR", date='18-03-2024')
 0.0016  # 0.16%
 ```
 

pyield-0.28.2/pyield/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.28.2"

{pyield-0.28.0/pyield/b3_futures → pyield-0.28.2/pyield/anbima}/__init__.py

@@ -15,7 +15,7 @@ ContractOptions = Literal["DI1", "DDI", "FRC", "DAP", "DOL", "WDO", "IND", "WIN"
 
 def futures(
     contract_code: ContractOptions,
-    trade_date: DateScalar,
+    date: DateScalar,
 ) -> pd.DataFrame:
     """
     Fetches data for a specified futures contract based on type and reference date.
@@ -31,7 +31,7 @@ def futures(
             - "WDO": Mini U.S. Dollar Futures from B3.
             - "IND": Ibovespa Futures from B3.
             - "WIN": Mini Ibovespa Futures from B3.
-        trade_date (DateScalar): The date for which to fetch the data.
+        date (DateScalar): The date for which to fetch the data.
             If the reference date is a string, it should be in 'DD-MM-YYYY' format.
 
     Returns:
@@ -58,14 +58,14 @@ def futures(
         ...
     """
     selected_contract = str(contract_code).upper()
-    converted_trade_date = dc.convert_input_dates(trade_date)
+    converted_date = dc.convert_input_dates(date)
 
     # First, try to fetch historical data for the specified date
-    df = fetch_historical_df(selected_contract, converted_trade_date)
+    df = fetch_historical_df(selected_contract, converted_date)
 
     bz_today = dt.datetime.now(TIMEZONE_BZ).date()
     # If there is no historical data available, try to fetch intraday data
-    if converted_trade_date.date() == bz_today and df.empty:
+    if converted_date.date() == bz_today and df.empty:
         df = fetch_intraday_df(selected_contract)
 
     return df

{pyield-0.28.0 → pyield-0.28.2}/pyield/anbima/tpf.py

@@ -19,9 +19,9 @@ ANBIMA_MEMBER_URL = "http://www.anbima.associados.rtm/merc_sec/arqs"
 FORMAT_CHANGE_DATE = pd.to_datetime("13-05-2014", dayfirst=True)
 
 
-def _get_file_content(reference_date: pd.Timestamp) -> str:
-    url_date = reference_date.strftime("%y%m%d")
-    if reference_date < FORMAT_CHANGE_DATE:
+def _get_file_content(date: pd.Timestamp) -> str:
+    url_date = date.strftime("%y%m%d")
+    if date < FORMAT_CHANGE_DATE:
         filename = f"ms{url_date}.exe"
     else:
         filename = f"ms{url_date}.txt"
@@ -41,7 +41,7 @@ def _get_file_content(reference_date: pd.Timestamp) -> str:
         # Checks if the response was successful (status code 200)
         r.raise_for_status()
 
-        if reference_date < FORMAT_CHANGE_DATE:
+        if date < FORMAT_CHANGE_DATE:
             zip_file = zp.ZipFile(io.BytesIO(r.content))
             file_content = zip_file.read(zip_file.namelist()[0]).decode("latin-1")
         else:
@@ -106,9 +106,7 @@ def _process_raw_df(df_raw: pd.DataFrame) -> pd.DataFrame:
     return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)
 
 
-def anbima_tpf_data(
-    reference_date: DateScalar, bond_type: str | None = None
-) -> pd.DataFrame:
+def anbima_tpf_data(date: DateScalar, bond_type: str | None = None) -> pd.DataFrame:
     """Fetch and process TPF market data from ANBIMA.
 
     This function retrieves bond market data from the ANBIMA website for a
@@ -116,7 +114,7 @@ def anbima_tpf_data(
     and attempts to download the data from both member and non-member URLs.
 
     Args:
-        reference_date (DateScalar): The reference date for the data.
+        date (DateScalar): The reference date for the data.
         bond_type (str, optional):  Filter data by bond type.
             Defaults to None, which returns data for all bond types.
 
@@ -126,8 +124,8 @@ def anbima_tpf_data(
             specified date.
     """
     # Normalize the reference date
-    reference_date = dc.convert_input_dates(reference_date)
-    file_content = _get_file_content(reference_date)
+    date = dc.convert_input_dates(date)
+    file_content = _get_file_content(date)
 
     if not file_content:
         return pd.DataFrame()
@@ -144,7 +142,7 @@ def anbima_tpf_data(
 
 
 def anbima_tpf_rates(
-    reference_date: DateScalar,
+    date: DateScalar,
     bond_type: str | None = None,
     adj_maturities: bool = False,
 ) -> pd.DataFrame:
@@ -156,7 +154,7 @@ def anbima_tpf_rates(
     website using the :func:`data` function.
 
     Args:
-        reference_date (DateScalar): The reference date for the rates.
+        date (DateScalar): The reference date for the rates.
         bond_type (str, optional): Filter rates by bond type.
             Defaults to None, which returns rates for all bond types.
         adj_maturities (bool, optional): Adjust maturity dates to the next
@@ -169,12 +167,12 @@ def anbima_tpf_rates(
     """
     df = get_anbima_dataset()
 
-    reference_date = dc.convert_input_dates(reference_date)
-    df.query("ReferenceDate == @reference_date", inplace=True)
+    date = dc.convert_input_dates(date)
+    df.query("ReferenceDate == @date", inplace=True)
 
     if df.empty:
         # Try to fetch the data from the Anbima website
-        df = anbima_tpf_data(reference_date)
+        df = anbima_tpf_data(date)
 
     if df.empty:
         # If the data is still empty, return an empty DataFrame
@@ -190,7 +188,7 @@ def anbima_tpf_rates(
     return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)
 
 
-def tpf_pre_maturities(reference_date: DateScalar) -> pd.Series:
+def tpf_pre_maturities(date: DateScalar) -> pd.Series:
     """Retrieve pre-defined maturity dates for LTN and NTN-F bonds.
 
     This function fetches pre-defined maturity dates for 'LTN' (prefixadas) and
@@ -198,14 +196,14 @@ def tpf_pre_maturities(reference_date: DateScalar) -> pd.Series:
     for a given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for maturity dates.
+        date (DateScalar): The reference date for maturity dates.
 
     Returns:
         pd.Series: A Series containing unique maturity dates for 'LTN' and
             'NTN-F' bonds, sorted in ascending order.
     """
     maturity_dates = (
-        anbima_tpf_rates(reference_date)
+        anbima_tpf_rates(date)
         .query("BondType in ['LTN', 'NTN-F']")["MaturityDate"]
         .drop_duplicates()
         .sort_values(ignore_index=True)

{pyield-0.28.0/pyield/anbima → pyield-0.28.2/pyield/b3_futures}/__init__.py

@@ -15,7 +15,7 @@ ContractOptions = Literal["DI1", "DDI", "FRC", "DAP", "DOL", "WDO", "IND", "WIN"
 
 def futures(
     contract_code: ContractOptions,
-    trade_date: DateScalar,
+    date: DateScalar,
 ) -> pd.DataFrame:
     """
     Fetches data for a specified futures contract based on type and reference date.
@@ -31,7 +31,7 @@ def futures(
             - "WDO": Mini U.S. Dollar Futures from B3.
             - "IND": Ibovespa Futures from B3.
             - "WIN": Mini Ibovespa Futures from B3.
-        trade_date (DateScalar): The date for which to fetch the data.
+        date (DateScalar): The date for which to fetch the data.
             If the reference date is a string, it should be in 'DD-MM-YYYY' format.
 
     Returns:
@@ -58,14 +58,14 @@ def futures(
         ...
     """
     selected_contract = str(contract_code).upper()
-    converted_trade_date = dc.convert_input_dates(trade_date)
+    converted_date = dc.convert_input_dates(date)
 
     # First, try to fetch historical data for the specified date
-    df = fetch_historical_df(selected_contract, converted_trade_date)
+    df = fetch_historical_df(selected_contract, converted_date)
 
     bz_today = dt.datetime.now(TIMEZONE_BZ).date()
     # If there is no historical data available, try to fetch intraday data
-    if converted_trade_date.date() == bz_today and df.empty:
+    if converted_date.date() == bz_today and df.empty:
         df = fetch_intraday_df(selected_contract)
 
     return df

{pyield-0.28.0 → pyield-0.28.2}/pyield/b3_futures/di.py

@@ -17,7 +17,7 @@ class DIFutures:
     NTN-F bond maturities.
 
     Args:
-        trade_date (DateScalar | None): The trade date to retrieve the
+        date (DateScalar | None): The trade date to retrieve the
             DI contract data. If None, the latest available historical trade date is
             used.
         month_start (bool): If True, adjusts the expirations to the start of the month.
@@ -28,7 +28,7 @@ class DIFutures:
 
     Examples:
         To create a `DIFutures` instance and retrieve data:
-        >>> dif = yd.DIFutures(trade_date="16-10-2024", month_start=True)
+        >>> dif = yd.DIFutures(date="16-10-2024", month_start=True)
         >>> df = dif.df  # Retrieve DI contract dataframe for the specified date
         >>> df.iloc[:5, :5]  # Show the first five rows and columns
            TradeDate ExpirationDate TickerSymbol  BDaysToExp  OpenContracts
@@ -48,7 +48,7 @@ class DIFutures:
         4 2024-10-16     2025-03-01          0.1157      0.12343
     """
 
-    historical_trade_dates = (
+    historical_dates = (
         get_di_dataset()
         .drop_duplicates(subset=["TradeDate"])["TradeDate"]
         .sort_values(ascending=True)
@@ -62,7 +62,7 @@ class DIFutures:
 
     def __init__(
         self,
-        trade_date: DateScalar | None = None,
+        date: DateScalar | None = None,
         month_start: bool = False,
         pre_filter: bool = False,
         all_columns: bool = True,
@@ -77,7 +77,7 @@ class DIFutures:
         self._df = pd.DataFrame()
         self._dirty = True  # Attribute to track if the df needs updating
 
-        self.trade_date = trade_date
+        self.date = date
         self.month_start = month_start
         self.pre_filter = pre_filter
         self.all_columns = all_columns
@@ -102,14 +102,14 @@ class DIFutures:
     def _update_df(self) -> pd.DataFrame:
         """Retrieve DI contract DataFrame for the initialized trade date."""
         bz_today = pd.Timestamp.today(tz="America/Sao_Paulo").normalize()
-        if bz_today == self.trade_date:
+        if bz_today == self.date:
             # Try to get intraday data
-            df = b3.futures(contract_code="DI1", trade_date=bz_today)
+            df = b3.futures(contract_code="DI1", date=bz_today)
         else:
             # Get historical data
             df = (
                 get_di_dataset()
-                .query("TradeDate == @self._trade_date")
+                .query("TradeDate == @self._date")
                 .reset_index(drop=True)
             )
 
@@ -123,7 +123,7 @@ class DIFutures:
             df_pre = (
                 get_anbima_dataset()
                 .query("BondType in ['LTN', 'NTN-F']")
-                .query("ReferenceDate == @self._trade_date")[
+                .query("ReferenceDate == @self._date")[
                     ["ReferenceDate", "MaturityDate"]
                 ]
                 .drop_duplicates()
@@ -197,7 +197,7 @@ class DIFutures:
 
     @staticmethod
     def interpolate_rates(
-        trade_dates: DateScalar | DateArray,
+        dates: DateScalar | DateArray,
         expirations: DateScalar | DateArray,
         extrapolate: bool = True,
     ) -> pd.Series:
@@ -209,12 +209,12 @@ class DIFutures:
         dates and maturities using a flat-forward interpolation method. If no DI
         rates are available for a reference date, the interpolated rate is set to NaN.
 
-        If trade_dates is provided as a scalar and expirations as an array, the
+        If dates is provided as a scalar and expirations as an array, the
         method assumes the scalar value is the same for all maturities. The same logic
         applies when the maturities are scalar and the trade dates are an array.
 
         Args:
-            trade_dates (DateScalar | DateArray): The trade dates for the rates.
+            dates (DateScalar | DateArray): The trade dates for the rates.
             expirations (DateScalar | DateArray): The expirations corresponding to the
                 trade dates.
             extrapolate (bool): Whether to allow extrapolation beyond known DI rates.
@@ -223,29 +223,29 @@ class DIFutures:
             pd.Series: A Series containing the interpolated DI rates.
 
         Raises:
-            ValueError: If `reference_dates` and `maturities` have different lengths.
+            ValueError: If `dates` and `maturities` have different lengths.
         """
         # Convert input dates to a consistent format
-        trade_dates = dc.convert_input_dates(trade_dates)
+        dates = dc.convert_input_dates(dates)
         expirations = dc.convert_input_dates(expirations)
 
         # Ensure the lengths of input arrays are consistent
-        match (trade_dates, expirations):
+        match (dates, expirations):
             case pd.Timestamp(), pd.Series():
                 dfi = pd.DataFrame({"mat": expirations})
-                dfi["tdate"] = trade_dates
+                dfi["tdate"] = dates
 
             case pd.Series(), pd.Timestamp():
-                dfi = pd.DataFrame({"tdate": trade_dates})
+                dfi = pd.DataFrame({"tdate": dates})
                 dfi["mat"] = expirations
 
             case pd.Series(), pd.Series():
-                if len(trade_dates) != len(expirations):
+                if len(dates) != len(expirations):
                     raise ValueError("Args. should have the same length.")
-                dfi = pd.DataFrame({"tdate": trade_dates, "mat": expirations})
+                dfi = pd.DataFrame({"tdate": dates, "mat": expirations})
 
             case pd.Timestamp(), pd.Timestamp():
-                dfi = pd.DataFrame({"tdate": [trade_dates], "mat": [expirations]})
+                dfi = pd.DataFrame({"tdate": [dates], "mat": [expirations]})
 
         # Compute business days between reference dates and maturities
         dfi["bdays"] = bday.count(dfi["tdate"], dfi["mat"])
@@ -332,11 +332,11 @@ class DIFutures:
             known_rates=df["SettlementRate"],
             extrapolate=extrapolate,
         )
-        bd = bday.count(self._trade_date, expiration)
+        bd = bday.count(self._date, expiration)
         return ff_interp(bd)
 
     @property
-    def trade_date(self) -> pd.Timestamp:
+    def date(self) -> pd.Timestamp:
         """
         The trade date to retrieve the DI contract data.
 
@@ -347,14 +347,14 @@ class DIFutures:
             pd.Timestamp: The trade date set for this instance.
         """
 
-        return self._trade_date
+        return self._date
 
-    @trade_date.setter
-    def trade_date(self, value: DateScalar | None):
+    @date.setter
+    def date(self, value: DateScalar | None):
         if value:
-            self._trade_date = dc.convert_input_dates(value)
+            self._date = dc.convert_input_dates(value)
         else:
-            self._trade_date = self.historical_trade_dates.max()
+            self._date = self.historical_dates.max()
 
         self._dirty = True
 

{pyield-0.28.0 → pyield-0.28.2}/pyield/b3_futures/historical.py

@@ -18,9 +18,7 @@ COUNT_CONVENTIONS = {
 }
 
 
-def get_old_expiration_date(
-    expiration_code: str, trade_date: pd.Timestamp
-) -> pd.Timestamp:
+def get_old_expiration_date(expiration_code: str, date: pd.Timestamp) -> pd.Timestamp:
     """
     Internal function to convert an old DI contract code into its ExpirationDate date.
     Valid for contract codes up to 21-05-2006.
@@ -29,7 +27,7 @@ def get_old_expiration_date(
         expiration_code (str): An old DI Expiration Code from B3, where the first three
             letters represent the month and the last digit represents the year.
             Example: "JAN3".
-        trade_date (pd.Timestamp): The trade date for which the contract code is valid.
+        date (pd.Timestamp): The trade date for which the contract code is valid.
 
     Returns:
         pd.Timestamp
@@ -64,7 +62,7 @@ def get_old_expiration_date(
         month = month_codes[month_code]
 
         # Year codes must generated dynamically, since it depends on the trade date.
-        reference_year = trade_date.year
+        reference_year = date.year
         year_codes = {}
         for year in range(reference_year, reference_year + 10):
             year_codes[str(year)[-1:]] = year
@@ -105,18 +103,18 @@ def _convert_prices_to_rates(
     return rates.round(5)
 
 
-def _fetch_raw_df(contract_code: str, trade_date: pd.Timestamp) -> pd.DataFrame:
+def _fetch_raw_df(contract_code: str, date: pd.Timestamp) -> pd.DataFrame:
     """
     Fetch the historical futures data from B3 for a specific trade date. If the data is
     not available, an empty DataFrame is returned.
 
     Args:
-        trade_date (pd.Timestamp): The trade date for which the data should be fetched.
+        date (pd.Timestamp): The trade date for which the data should be fetched.
 
     Returns:
         pd.DataFrame: Raw DI data as a Pandas pd.DataFrame.
     """
-    url_date = trade_date.strftime("%d/%m/%Y")
+    url_date = date.strftime("%d/%m/%Y")
     # url example: https://www2.bmf.com.br/pages/portal/bmfbovespa/boletim1/SistemaPregao_excel1.asp?Data=05/10/2023&Mercadoria=DI1
     url = f"https://www2.bmf.com.br/pages/portal/bmfbovespa/boletim1/SistemaPregao_excel1.asp?Data={url_date}&Mercadoria={contract_code}&XLS=false"
     r = requests.get(url, timeout=10)
@@ -185,19 +183,19 @@ def _rename_columns(df: pd.DataFrame) -> pd.DataFrame:
 
 
 def process_df(
-    input_df: pd.DataFrame, trade_date: pd.Timestamp, asset_code: str
+    input_df: pd.DataFrame, date: pd.Timestamp, asset_code: str
 ) -> pd.DataFrame:
     df = input_df.copy()
-    df["TradeDate"] = trade_date
+    df["TradeDate"] = date
     # Convert to datetime64[ns] since it is pandas default type for timestamps
     df["TradeDate"] = df["TradeDate"].astype("datetime64[ns]")
 
     df["TickerSymbol"] = asset_code + df["ExpirationCode"]
 
     # Contract code format was changed in 22/05/2006
-    if trade_date < pd.Timestamp("2006-05-22"):
+    if date < pd.Timestamp("2006-05-22"):
         df["ExpirationDate"] = df["ExpirationCode"].apply(
-            get_old_expiration_date, args=(trade_date,)
+            get_old_expiration_date, args=(date,)
         )
     else:
         expiration_day = 15 if asset_code == "DAP" else 1
@@ -205,11 +203,11 @@ def process_df(
             common.get_expiration_date, args=(expiration_day,)
         )
 
-    df["DaysToExp"] = (df["ExpirationDate"] - trade_date).dt.days
+    df["DaysToExp"] = (df["ExpirationDate"] - date).dt.days
     # Convert to nullable integer, since it is the default type in the library
     df["DaysToExp"] = df["DaysToExp"].astype("Int64")
 
-    df["BDaysToExp"] = bday.count(trade_date, df["ExpirationDate"])
+    df["BDaysToExp"] = bday.count(date, df["ExpirationDate"])
 
     # Remove expired contracts
     df.query("DaysToExp > 0", inplace=True)
@@ -223,7 +221,7 @@ def process_df(
 
     rate_cols = [col for col in df.columns if "Rate" in col]
     # Prior to 17/01/2002 (inclusive), DI prices were not converted to rates
-    if trade_date <= pd.Timestamp("2002-01-17") and asset_code == "DI1":
+    if date <= pd.Timestamp("2002-01-17") and asset_code == "DI1":
         df = _adjust_older_contracts_rates(df, rate_cols)
     else:
         # Remove % and round to 5 (3 in %) dec. places in rate columns
@@ -281,7 +279,7 @@ def _select_and_reorder_columns(df: pd.DataFrame):
     return df[reordered_columns]
 
 
-def fetch_historical_df(contract_code: str, trade_date: pd.Timestamp) -> pd.DataFrame:
+def fetch_historical_df(contract_code: str, date: pd.Timestamp) -> pd.DataFrame:
     """
     Fetchs the futures data for a given date from B3.
 
@@ -290,7 +288,7 @@ def fetch_historical_df(contract_code: str, trade_date: pd.Timestamp) -> pd.Data
 
     Args:
         asset_code (str): The asset code to fetch the futures data.
-        trade_date (pd.Timestamp): The trade date to fetch the futures data.
+        date (pd.Timestamp): The trade date to fetch the futures data.
         count_convention (int): The count convention for the DI futures contract.
             Can be 252 business days or 360 calendar days.
 
@@ -298,11 +296,11 @@ def fetch_historical_df(contract_code: str, trade_date: pd.Timestamp) -> pd.Data
         pd.DataFrame: A Pandas pd.DataFrame containing processed futures data. If
             the data is not available, an empty DataFrame is returned.
     """
-    df_raw = _fetch_raw_df(contract_code, trade_date)
+    df_raw = _fetch_raw_df(contract_code, date)
     if df_raw.empty:
         return df_raw
 
     df = _rename_columns(df_raw)
-    df = process_df(df, trade_date, contract_code)
+    df = process_df(df, date, contract_code)
     df = _select_and_reorder_columns(df)
     return df

{pyield-0.28.0 → pyield-0.28.2}/pyield/b3_futures/xml.py

@@ -22,7 +22,7 @@ def _get_file_from_path(file_path: Path) -> io.BytesIO:
     return io.BytesIO(content)
 
 
-def _get_file_from_url(trade_date: pd.Timestamp, source_type: str) -> io.BytesIO:
+def _get_file_from_url(date: pd.Timestamp, source_type: str) -> io.BytesIO:
     """
     Types of XML files available:
     Full Price Report (all assets)
@@ -33,12 +33,14 @@ def _get_file_from_url(trade_date: pd.Timestamp, source_type: str) -> io.BytesIO
         url example: https://www.b3.com.br/pesquisapregao/download?filelist=SPRD240216.zip
     """
 
-    trade_date_str = trade_date.strftime("%y%m%d")
+    date_str = date.strftime("%y%m%d")
 
     if source_type == "PR":
-        url = f"https://www.b3.com.br/pesquisapregao/download?filelist=PR{trade_date_str}.zip"
+        url = f"https://www.b3.com.br/pesquisapregao/download?filelist=PR{date_str}.zip"
     elif source_type == "SPR":
-        url = f"https://www.b3.com.br/pesquisapregao/download?filelist=SPRD{trade_date_str}.zip"
+        url = (
+            f"https://www.b3.com.br/pesquisapregao/download?filelist=SPRD{date_str}.zip"
+        )
     else:
         raise ValueError("Invalid source type. Must be either 'PR' or 'SPR'.")
 
@@ -46,8 +48,8 @@ def _get_file_from_url(trade_date: pd.Timestamp, source_type: str) -> io.BytesIO
 
     # File will be considered invalid if it is too small
     if response.status_code != 200 or len(response.content) < 1024:
-        trade_date_str = trade_date.strftime("%Y-%m-%d")
-        raise ValueError(f"There is no data available for {trade_date_str}.")
+        date_str = date.strftime("%Y-%m-%d")
+        raise ValueError(f"There is no data available for {date_str}.")
 
     return io.BytesIO(response.content)
 
@@ -112,12 +114,12 @@ def _extract_data_from_xml(xml_file: io.BytesIO, asset_code: str) -> list[dict]:
             continue
 
         # Extract the trade date
-        trade_date = price_report.find(".//ns:TradDt/ns:Dt", namespaces)
-        if trade_date is None:
+        date = price_report.find(".//ns:TradDt/ns:Dt", namespaces)
+        if date is None:
             continue
 
         # Store the data in a dictionary
-        ticker_data = {"TradDt": trade_date.text, "TckrSymb": ticker.text}
+        ticker_data = {"TradDt": date.text, "TckrSymb": ticker.text}
 
         # Extract the FinInstrmAttrbts element
         fin_instrm_attrbts = price_report.find(".//ns:FinInstrmAttrbts", namespaces)
@@ -260,9 +262,9 @@ def process_zip_file(zip_file: io.BytesIO, asset_code: str) -> pd.DataFrame:
 
 
 def fetch_df(
-    trade_date: pd.Timestamp, asset_code: str, source_type: Literal["PR", "SPR"]
+    date: pd.Timestamp, asset_code: str, source_type: Literal["PR", "SPR"]
 ) -> pd.DataFrame:
-    zip_file = _get_file_from_url(trade_date, source_type)
+    zip_file = _get_file_from_url(date, source_type)
     df = process_zip_file(zip_file, asset_code)
     return df
 

{pyield-0.28.0 → pyield-0.28.2}/pyield/indicators.py

@@ -19,7 +19,7 @@ MAX_ATTEMPTS = 10
 
 def indicator(
     indicator_code: Literal["IPCA_MR", "SELIC_TARGET", "SELIC_OVER", "DI", "VNA_LFT"],
-    reference_date: DateScalar,
+    date: DateScalar,
 ) -> float:
     """
     Fetches the economic indicator value for a specified reference date.
@@ -37,7 +37,7 @@ def indicator(
             - "SELIC_OVER": SELIC Over (overnight) rate.
             - "DI": DI (interbank deposit rate).
             - "VNA_LFT": Valor Nominal Atualizado for LFT (Treasury Bills).
-        reference_date (DateScalar): The date for which the indicator value is
+        date (DateScalar): The date for which the indicator value is
             fetched. If passed as a string, it should be in 'DD-MM-YYYY' format.
 
     Returns:
@@ -65,7 +65,7 @@ def indicator(
         0.104
 
     """
-    converted_date = dc.convert_input_dates(reference_date)
+    converted_date = dc.convert_input_dates(date)
     selected_indicator_code = str(indicator_code).upper()
     match selected_indicator_code:
         case "IPCA_MR":
@@ -82,7 +82,7 @@ def indicator(
             raise ValueError("Invalid indicator code provided")
 
 
-def ipca_monthly_rate(reference_date: pd.Timestamp) -> float:
+def ipca_monthly_rate(date: pd.Timestamp) -> float:
     """
     The function makes an API call to the IBGE's data portal to retrieve the data.
     An example of the API call: https://servicodados.ibge.gov.br/api/v3/agregados/6691/periodos/202403/variaveis/63?localidades=N1[all]
@@ -90,14 +90,14 @@ def ipca_monthly_rate(reference_date: pd.Timestamp) -> float:
     The API URL is constructed dynamically based on the reference date provided.
     """
     # Format the date as 'YYYYMM' for the API endpoint
-    ipca_date = reference_date.strftime("%Y%m")
+    ipca_date = date.strftime("%Y%m")
 
     # Construct the API URL using the formatted date
     api_url = f"https://servicodados.ibge.gov.br/api/v3/agregados/6691/periodos/{ipca_date}/variaveis/63?localidades=N1[all]"
 
     def process_ipca_response(data):
         if not data:
-            msg = f"No data available for IPCA Monthly Rate on {reference_date}"
+            msg = f"No data available for IPCA Monthly Rate on {date}"
             logger.warning(msg)
             return float("nan")
         ipca_str = data[0]["resultados"][0]["series"][0]["serie"][ipca_date]
@@ -106,28 +106,28 @@ def ipca_monthly_rate(reference_date: pd.Timestamp) -> float:
     return _fetch_with_retry(api_url, "IPCA Monthly Rate", process_ipca_response, True)
 
 
-def _selic_target(reference_date: pd.Timestamp) -> float:
+def _selic_target(date: pd.Timestamp) -> float:
     """
     Fetches the SELIC Target rate for a specific reference date.
 
     The SELIC Target rate is the official rate set by the Central Bank of Brazil.
 
     Args:
-        reference_date (pd.Timestamp): The date for which to fetch the SELIC Target.
+        date (pd.Timestamp): The date for which to fetch the SELIC Target.
 
     Returns:
         float: The SELIC Target rate as a float rounded to 4 decimal places or NaN if
         the rate is not available.
     """
     # https://api.bcb.gov.br/dados/serie/bcdata.sgs.432/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
-    selic_date = reference_date.strftime("%d/%m/%Y")
+    selic_date = date.strftime("%d/%m/%Y")
     api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.432/dados?formato=csv&dataInicial={selic_date}&dataFinal={selic_date}"
 
     def process_selic_target_response(data):
         csv_data = io.StringIO(data)
         df = pd.read_csv(csv_data, sep=";", decimal=",")
         if df.empty or "valor" not in df.columns:
-            msg = f"No data available for SELIC Target rate on {reference_date}"
+            msg = f"No data available for SELIC Target rate on {date}"
             logger.warning(msg)
             return float("nan")
         value = float(df["valor"].iloc[0] / 100)  # SELIC Target rate
@@ -138,7 +138,7 @@ def _selic_target(reference_date: pd.Timestamp) -> float:
     )
 
 
-def _selic_over(reference_date: pd.Timestamp) -> float:
+def _selic_over(date: pd.Timestamp) -> float:
     """
     Fetches the SELIC Over rate for a specific reference date.
 
@@ -146,14 +146,14 @@ def _selic_over(reference_date: pd.Timestamp) -> float:
     between banks in the interbank market, using public securities as collateral.
 
     Args:
-        reference_date (pd.Timestamp): The date for which to fetch the SELIC Over rate.
+        date (pd.Timestamp): The date for which to fetch the SELIC Over rate.
 
     Returns:
         float: The SELIC Over rate as a float rounded to 4 decimal places or NaN if
         the rate is not available.
     """
 
-    formatted_date = reference_date.strftime("%d/%m/%Y")
+    formatted_date = date.strftime("%d/%m/%Y")
     # https://api.bcb.gov.br/dados/serie/bcdata.sgs.1178/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
     api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.1178/dados?formato=csv&dataInicial={formatted_date}&dataFinal={formatted_date}"
 
@@ -161,7 +161,7 @@ def _selic_over(reference_date: pd.Timestamp) -> float:
         csv_data = io.StringIO(data)
         df = pd.read_csv(csv_data, sep=";", decimal=",")
         if df.empty or "valor" not in df.columns:
-            msg = f"No data available for SELIC Over rate on {reference_date}"
+            msg = f"No data available for SELIC Over rate on {date}"
             logger.warning(msg)
             return float("nan")
         value = float(df["valor"].iloc[0] / 100)  # SELIC Over daily rate
@@ -170,16 +170,16 @@ def _selic_over(reference_date: pd.Timestamp) -> float:
     return _fetch_with_retry(api_url, "SELIC Over", process_selic_over_response, False)
 
 
-def _di(reference_date: pd.Timestamp) -> float:
+def _di(date: pd.Timestamp) -> float:
     # https://api.bcb.gov.br/dados/serie/bcdata.sgs.11/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
-    di_date = reference_date.strftime("%d/%m/%Y")
+    di_date = date.strftime("%d/%m/%Y")
     api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.11/dados?formato=csv&dataInicial={di_date}&dataFinal={di_date}"
 
     def process_di_response(data):
         csv_data = io.StringIO(data)
         df = pd.read_csv(csv_data, sep=";", decimal=",")
         if df.empty or "valor" not in df.columns:
-            logger.warning(f"No data available for DI rate on {reference_date}")
+            logger.warning(f"No data available for DI rate on {date}")
             return float("nan")
         value = float(df["valor"].iloc[0] / 100)  # DI daily rate
         return round((1 + value) ** 252 - 1, 4)  # Annualize the daily rate
@@ -187,10 +187,10 @@ def _di(reference_date: pd.Timestamp) -> float:
     return _fetch_with_retry(api_url, "DI Over", process_di_response, False)
 
 
-def _vna_lft(reference_date: pd.Timestamp) -> float:
+def _vna_lft(date: pd.Timestamp) -> float:
     # url example: https://www3.bcb.gov.br/novoselic/rest/arquivosDiarios/pub/download/3/20240418APC238
     url_base = "https://www3.bcb.gov.br/novoselic/rest/arquivosDiarios/pub/download/3/"
-    url_file = f"{reference_date.strftime('%Y%m%d')}APC238"
+    url_file = f"{date.strftime('%Y%m%d')}APC238"
     url_vna = url_base + url_file
 
     def _process_vna_response(text: str) -> float:

{pyield-0.28.0 → pyield-0.28.2}/pyield/projections.py

@@ -1,11 +1,8 @@
-import io
 import locale
 from dataclasses import dataclass
 from typing import Literal
 
 import pandas as pd
-import python_calamine as pc
-import requests
 
 
 @dataclass
@@ -62,32 +59,23 @@ def ipca_current_month() -> IndicatorProjection:
     """
     # Define the URL and get the data
     url = "https://www.anbima.com.br/informacoes/indicadores/arqs/indicadores.xls"
-    response = requests.get(url, timeout=10)
-    excel_data = io.BytesIO(response.content)
+    df = pd.read_excel(url)
 
-    # Load the workbook and select the first sheet
-    workbook = pc.load_workbook(excel_data)
-    first_sheet = workbook.sheet_names[0]
-    data = workbook.get_sheet_by_name(first_sheet).to_python(skip_empty_area=True)
+    last_update_str = df.columns[0].split("Atualização:")[-1].strip()
 
-    # Extract projection update date and time from the first row
-    update_str = str(data[0][0])
-    last_update_str = update_str.split("Atualização:")[-1].strip()
-
-    # Find the text containing the IPCA projection and extract its data
-    ipca_data = next(line for line in data if "IPCA1" in line)
-    ipca_text = str(ipca_data[-1])
+    ipca_row = df[df.iloc[:, 0] == "IPCA1"]
+    ipca_date = ipca_row.iloc[0, 1]
+    ipca_value = ipca_row.iloc[0, 2]
 
     # Extract and format the reference month
-    projection_text = str(ipca_data[1])
-    month_str = projection_text.split("(")[-1].split(")")[0]
+    ipca_date = ipca_date.split("(")[-1].split(")")[0]
     locale.setlocale(locale.LC_TIME, "pt_BR.UTF-8")
-    ipca_month_ts = pd.to_datetime(month_str, format="%b/%y")
-    reference_period = ipca_month_ts.to_period("M")
+    ipca_date = pd.to_datetime(ipca_date, format="%b/%y")
+    reference_period = ipca_date.to_period("M")
     locale.setlocale(locale.LC_TIME, "")  # Reset locale to default
 
     return IndicatorProjection(
         last_updated=pd.to_datetime(last_update_str, format="%d/%m/%Y - %H:%M h"),
         reference_period=reference_period,
-        projected_value=round(float(ipca_text) / 100, 4),
+        projected_value=round(float(ipca_value) / 100, 4),
     )

{pyield-0.28.0 → pyield-0.28.2}/pyield/tpf/lft.py

@@ -7,33 +7,33 @@ from pyield.date_converter import DateScalar
 from pyield.tpf import tools as tt
 
 
-def rates(reference_date: DateScalar) -> pd.DataFrame:
+def rates(date: DateScalar) -> pd.DataFrame:
     """
     Fetch the bond Anbima indicative rates for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
     """
-    lft_rates = tpf.anbima_tpf_rates(reference_date, "LFT")
+    lft_rates = tpf.anbima_tpf_rates(date, "LFT")
     if lft_rates.empty:
         return pd.DataFrame()
     return lft_rates[["MaturityDate", "IndicativeRate"]]
 
 
-def maturities(reference_date: DateScalar) -> pd.Series:
+def maturities(date: DateScalar) -> pd.Series:
     """
     Fetch the bond maturities available for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.Series: A Series of bond maturities available for the reference date.
     """
-    df_rates = rates(reference_date)
+    df_rates = rates(date)
     return df_rates["MaturityDate"]
 
 

{pyield-0.28.0 → pyield-0.28.2}/pyield/tpf/ltn.py

@@ -10,12 +10,12 @@ from pyield.tpf import tools as tt
 FACE_VALUE = 1000
 
 
-def rates(reference_date: DateScalar) -> pd.DataFrame:
+def rates(date: DateScalar) -> pd.DataFrame:
     """
     Fetch the LTN Anbima indicative rates for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
@@ -38,18 +38,18 @@ def rates(reference_date: DateScalar) -> pd.DataFrame:
         12   2030-01-01        0.118746
 
     """
-    ltn_rates = tpf.anbima_tpf_rates(reference_date, "LTN")
+    ltn_rates = tpf.anbima_tpf_rates(date, "LTN")
     if ltn_rates.empty:
         return pd.DataFrame()
     return ltn_rates[["MaturityDate", "IndicativeRate"]]
 
 
-def maturities(reference_date: DateScalar) -> pd.Series:
+def maturities(date: DateScalar) -> pd.Series:
     """
     Fetch the bond maturities available for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.Series: A Series of bond maturities available for the reference date.
@@ -72,7 +72,7 @@ def maturities(reference_date: DateScalar) -> pd.Series:
         dtype: datetime64[ns]
 
     """
-    df_rates = rates(reference_date)
+    df_rates = rates(date)
     s_maturities = df_rates["MaturityDate"]
     s_maturities.name = None
     return s_maturities
@@ -121,7 +121,7 @@ def price(
     return tt.truncate(FACE_VALUE / discount_factor, 6)
 
 
-def di_spreads(reference_date: DateScalar) -> pd.DataFrame:
+def di_spreads(date: DateScalar) -> pd.DataFrame:
     """
     Calculates the DI spread for the LTN based on ANBIMA's indicative rates.
 
@@ -129,7 +129,7 @@ def di_spreads(reference_date: DateScalar) -> pd.DataFrame:
     rates and calculates the spread between these rates in basis points.
 
     Parameters:
-        reference_date (DateScalar, optional): The reference date for the
+        date (DateScalar, optional): The reference date for the
             spread calculation.
 
     Returns:
@@ -153,7 +153,7 @@ def di_spreads(reference_date: DateScalar) -> pd.DataFrame:
         12   2030-01-01     14.96
     """
     # Fetch DI Spreads for the reference date
-    df = tt.pre_spreads(reference_date)
+    df = tt.pre_spreads(date)
     df.query("BondType == 'LTN'", inplace=True)
     df.sort_values(["MaturityDate"], ignore_index=True, inplace=True)
     return df[["MaturityDate", "DISpread"]]
@@ -186,14 +186,14 @@ def premium(ltn_rate: float, di_rate: float) -> float:
 
 
 def historical_premium(
-    reference_date: DateScalar,
+    date: DateScalar,
     maturity: DateScalar,
 ) -> float:
     """
     Calculate the premium of the LTN bond over the DI Future rate for a given date.
 
     Args:
-        reference_date (DateScalar): The reference date to fetch the rates.
+        date (DateScalar): The reference date to fetch the rates.
         maturity (DateScalar): The maturity date of the LTN bond.
 
     Returns:
@@ -206,11 +206,11 @@ def historical_premium(
 
     """
     # Convert input dates to a consistent format
-    reference_date = dc.convert_input_dates(reference_date)
+    date = dc.convert_input_dates(date)
     maturity = dc.convert_input_dates(maturity)
 
     # Retrieve LTN rates for the reference date
-    df_anbima = rates(reference_date)
+    df_anbima = rates(date)
     if df_anbima.empty:
         return float("NaN")
 
@@ -221,7 +221,7 @@ def historical_premium(
     ltn_rate = float(ltn_rates.iloc[0])
 
     # Retrieve DI rate for the reference date and maturity
-    dif = di.DIFutures(trade_date=reference_date)
+    dif = di.DIFutures(date=date)
     di_rate = dif.rate(expiration=maturity, interpolate=True, extrapolate=False)
     if pd.isnull(di_rate):  # Check if the DI rate is NaN
         return float("NaN")

{pyield-0.28.0 → pyield-0.28.2}/pyield/tpf/ntnb.py

@@ -53,12 +53,12 @@ def _check_maturities(
         raise ValueError("NTN-B maturity must be 15/02, 15/05, 15/08 or 15/11.")
 
 
-def rates(reference_date: DateScalar) -> pd.DataFrame:
+def rates(date: DateScalar) -> pd.DataFrame:
     """
     Fetch the bond indicative rates for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
@@ -86,18 +86,18 @@ def rates(reference_date: DateScalar) -> pd.DataFrame:
         13   2060-08-15        0.060179
 
     """
-    ntnb_rates = tpf.anbima_tpf_rates(reference_date, "NTN-B")
+    ntnb_rates = tpf.anbima_tpf_rates(date, "NTN-B")
     if ntnb_rates.empty:
         return pd.DataFrame()
     return ntnb_rates[["MaturityDate", "IndicativeRate"]]
 
 
-def maturities(reference_date: DateScalar) -> pd.Series:
+def maturities(date: DateScalar) -> pd.Series:
     """
     Get the bond maturities available for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.Series: Series containing the maturity dates for the NTN-B bonds.
@@ -122,7 +122,7 @@ def maturities(reference_date: DateScalar) -> pd.Series:
         dtype: datetime64[ns]
 
     """
-    df_rates = rates(reference_date)
+    df_rates = rates(date)
     s_maturities = df_rates["MaturityDate"]
     s_maturities.name = None
     return s_maturities

{pyield-0.28.0 → pyield-0.28.2}/pyield/tpf/ntnf.py

@@ -3,7 +3,7 @@ from collections.abc import Callable
 import numpy as np
 import pandas as pd
 
-from pyield import bday, data_cache
+from pyield import bday
 from pyield import date_converter as dc
 from pyield import interpolator as ip
 from pyield.anbima import tpf
@@ -24,23 +24,12 @@ COUPON_PMT = 48.80885
 FINAL_PMT = 1048.80885
 
 
-def reference_dates() -> pd.Series:
-    """
-    Fetch the NTN-F bond reference dates available in the Anbima database.
-
-    Returns:
-        pd.Series: A Series of NTN-F bond reference dates.
-    """
-    df = data_cache.get_anbima_dataset().query("BondType == 'NTN-F'")
-    return df["ReferenceDate"].drop_duplicates().sort_values().reset_index(drop=True)
-
-
-def rates(reference_date: DateScalar) -> pd.DataFrame:
+def rates(date: DateScalar) -> pd.DataFrame:
     """
     Fetch the bond indicative rates for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
@@ -55,18 +44,18 @@ def rates(reference_date: DateScalar) -> pd.DataFrame:
         4   2033-01-01        0.116307
         5   2035-01-01        0.116586
     """
-    ntnf_rates = tpf.anbima_tpf_rates(reference_date, "NTN-F")
+    ntnf_rates = tpf.anbima_tpf_rates(date, "NTN-F")
     if ntnf_rates.empty:
         return pd.DataFrame()
     return ntnf_rates[["MaturityDate", "IndicativeRate"]]
 
 
-def maturities(reference_date: DateScalar) -> pd.Series:
+def maturities(date: DateScalar) -> pd.Series:
     """
     Fetch the NTN-F bond maturities available for the given reference date.
 
     Args:
-        reference_date (DateScalar): The reference date for fetching the data.
+        date (DateScalar): The reference date for fetching the data.
 
     Returns:
         pd.Series: A Series of NTN-F bond maturities available for the reference date.
@@ -82,7 +71,7 @@ def maturities(reference_date: DateScalar) -> pd.Series:
         dtype: datetime64[ns]
 
     """
-    df_rates = rates(reference_date)
+    df_rates = rates(date)
     s_maturities = df_rates["MaturityDate"]
     s_maturities.name = None
     return s_maturities
@@ -341,7 +330,7 @@ def spot_rates(  # noqa
     return df
 
 
-def di_spreads(reference_date: DateScalar) -> pd.DataFrame:
+def di_spreads(date: DateScalar) -> pd.DataFrame:
     """
     Calculates the DI spread for the NTN-F based on ANBIMA's indicative rates.
 
@@ -349,7 +338,7 @@ def di_spreads(reference_date: DateScalar) -> pd.DataFrame:
     rates and calculates the spread between these rates in basis points.
 
     Parameters:
-        reference_date (DateScalar): The reference date for the spread calculation.
+        date (DateScalar): The reference date for the spread calculation.
 
     Returns:
         pd.DataFrame: DataFrame with columns "MaturityDate", "DISpread".
@@ -366,7 +355,7 @@ def di_spreads(reference_date: DateScalar) -> pd.DataFrame:
 
     """
     # Fetch DI Spreads for the reference date
-    df = tt.pre_spreads(reference_date)
+    df = tt.pre_spreads(date)
     df = (
         df.query("BondType == 'NTN-F'")
         .sort_values(["MaturityDate"])
@@ -587,13 +576,13 @@ def premium(
 
 
 def historical_premium(
-    reference_date: DateScalar,
+    date: DateScalar,
     maturity: DateScalar,
 ) -> float:
-    reference_date = dc.convert_input_dates(reference_date)
+    date = dc.convert_input_dates(date)
     maturity = dc.convert_input_dates(maturity)
 
-    df_ntnf = rates(reference_date)
+    df_ntnf = rates(date)
     if df_ntnf.empty:
         return float("NaN")
 
@@ -602,14 +591,14 @@ def historical_premium(
         return float("NaN")
     ntnf_ytm = float(ntnf_ytms.iloc[0])
 
-    df = cash_flows(reference_date, maturity, adj_payment_dates=True)
-    df["BDToMat"] = bday.count(reference_date, df["PaymentDate"])
+    df = cash_flows(date, maturity, adj_payment_dates=True)
+    df["BDToMat"] = bday.count(date, df["PaymentDate"])
     df["BYears"] = df["BDToMat"] / 252
-    df["ReferenceDate"] = reference_date
+    df["ReferenceDate"] = date
 
     dif = di.DIFutures()  # Instantiate the DI Futures class
     df["DIRate"] = dif.interpolate_rates(
-        trade_dates=df["ReferenceDate"],
+        dates=df["ReferenceDate"],
         expirations=df["PaymentDate"],
         extrapolate=False,
     )

{pyield-0.28.0 → pyield-0.28.2}/pyield/tpf/tools.py

@@ -58,7 +58,7 @@ def calculate_present_value(
     return (cash_flows / (1 + rates) ** periods).sum()
 
 
-def pre_spreads(reference_date: DateScalar) -> pd.DataFrame:
+def pre_spreads(date: DateScalar) -> pd.DataFrame:
     """
     Calculates the DI spread for Brazilian treasury bonds (LTN and NTN-F) based on
     ANBIMA's indicative rates.
@@ -69,15 +69,15 @@ def pre_spreads(reference_date: DateScalar) -> pd.DataFrame:
     provided, the function uses the previous business day.
 
     Parameters:
-        reference_date (DateScalar): The reference date for the spread calculation.
+        date (DateScalar): The reference date for the spread calculation.
 
     Returns:
         pd.DataFrame: DataFrame containing the bond type, maturity date and the
             calculated spread in basis points.
     """
     # Fetch DI rates for the reference date
-    converted_date = dc.convert_input_dates(reference_date)
-    di = DIFutures(trade_date=converted_date, month_start=True)
+    converted_date = dc.convert_input_dates(date)
+    di = DIFutures(date=converted_date, month_start=True)
     df_di = di.df
     if "SettlementRate" not in df_di.columns:
         raise ValueError("DI rates data is missing the 'SettlementRate' column.")

{pyield-0.28.0 → pyield-0.28.2}/pyproject.toml

@@ -14,9 +14,8 @@ classifiers = [
     "Topic :: Office/Business :: Financial :: Investment",
 ]
 dependencies = [
-    "pandas[html,parquet]>=2.0.0",
-    "numpy>=2.0.0",
-    "python-calamine>=0.2.0",    
+    "pandas[html,parquet,excel]>=2.0.0",
+    "numpy>=2.0.0",    
     "requests>=2.31.0",
 ]
 dynamic = ["version"]

pyield-0.28.0/pyield/__about__.py

@@ -1 +0,0 @@
-__version__ = "0.28.0"