PYield 0.7.7__tar.gz → 0.7.9__tar.gz

{pyield-0.7.7 → pyield-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PYield
-Version: 0.7.7
+Version: 0.7.9
 Summary: A Python library for analysis of fixed income instruments in Brazil
 Keywords: fixed-income, brazil, finance, analysis, bonds
 Author-Email: Carlos Carvalho <cr.cj@outlook.com>
@@ -32,13 +32,13 @@ Classifier: Intended Audience :: Financial and Insurance Industry
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Project-URL: Source, https://github.com/crdcj/PYield
 Requires-Python: >=3.11
-Requires-Dist: requests
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: numpy
 Requires-Dist: beautifulsoup4
 Requires-Dist: html5lib
 Requires-Dist: lxml
 Requires-Dist: python-calamine>=0.2.0
+Requires-Dist: requests>=2.31.0
 Description-Content-Type: text/markdown
 
 [![PyPI version](https://img.shields.io/pypi/v/pyield.svg)](https://pypi.python.org/pypi/pyield)
@@ -101,7 +101,7 @@ dtype: datetime64[ns]
 ```python
 # Fetch current DI Futures data from B3 (15 minutes delay)
 >>> yd.fetch_asset(asset_code="DI1")
-TradeTimestamp      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate LastRate
+TradeTimestamp      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate CurrentRate
 2024-04-21 13:37:39       DI1K24     2024-05-02          7 ... 0.10660     0.10652     0.10660  0.10660
 2024-04-21 13:37:39       DI1M24     2024-06-03         28 ... 0.10518     0.10510     0.10516  0.10518
 2024-04-21 13:37:39       DI1N24     2024-07-01         48 ... 0.10480     0.10456     0.10462  0.10460
@@ -158,11 +158,11 @@ BondType ReferenceDate MaturityDate  DISpread
 ```python
 # Fetch the SELIC target rate from the Central Bank of Brazil
 >>> yd.fetch_indicator(indicator_code="SELIC", reference_date='2024-04-12')
-10.75
+0.1075  # 10.75%
 
 # Fetch the IPCA monthly inflation rate from IBGE
 >>> yd.fetch_indicator(indicator_code="IPCA", reference_date='2024-03-18')
-0.16
+0.16  # 0.16%
 
 # If no data is yet available for the indicator, the function returns None
 >>> yd.fetch_indicator(indicator_code="IPCA", reference_date='2024-04-10')
@@ -178,9 +178,9 @@ IndicatorProjection(
     last_updated=Timestamp('2024-04-19 18:55:00'),
     reference_month_ts=Timestamp('2024-04-01 00:00:00'),
     reference_month_br='ABR/2024',
-    projected_value=0.0035
+    projected_value=0.0035  # 0.35%
 )
 >>> ipca.projected_value
-0.0035
+0.0035  # 0.35%
 ```
 

{pyield-0.7.7 → pyield-0.7.9}/README.md

@@ -58,7 +58,7 @@ dtype: datetime64[ns]
 ```python
 # Fetch current DI Futures data from B3 (15 minutes delay)
 >>> yd.fetch_asset(asset_code="DI1")
-TradeTimestamp      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate LastRate
+TradeTimestamp      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate CurrentRate
 2024-04-21 13:37:39       DI1K24     2024-05-02          7 ... 0.10660     0.10652     0.10660  0.10660
 2024-04-21 13:37:39       DI1M24     2024-06-03         28 ... 0.10518     0.10510     0.10516  0.10518
 2024-04-21 13:37:39       DI1N24     2024-07-01         48 ... 0.10480     0.10456     0.10462  0.10460
@@ -115,11 +115,11 @@ BondType ReferenceDate MaturityDate  DISpread
 ```python
 # Fetch the SELIC target rate from the Central Bank of Brazil
 >>> yd.fetch_indicator(indicator_code="SELIC", reference_date='2024-04-12')
-10.75
+0.1075  # 10.75%
 
 # Fetch the IPCA monthly inflation rate from IBGE
 >>> yd.fetch_indicator(indicator_code="IPCA", reference_date='2024-03-18')
-0.16
+0.16  # 0.16%
 
 # If no data is yet available for the indicator, the function returns None
 >>> yd.fetch_indicator(indicator_code="IPCA", reference_date='2024-04-10')
@@ -135,9 +135,9 @@ IndicatorProjection(
     last_updated=Timestamp('2024-04-19 18:55:00'),
     reference_month_ts=Timestamp('2024-04-01 00:00:00'),
     reference_month_br='ABR/2024',
-    projected_value=0.0035
+    projected_value=0.0035  # 0.35%
 )
 >>> ipca.projected_value
-0.0035
+0.0035  # 0.35%
 ```
 

pyield-0.7.9/pyield/__about__.py

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

{pyield-0.7.7 → pyield-0.7.9}/pyield/__init__.py

@@ -1,7 +1,11 @@
 from .__about__ import __version__
 from .bday import count_bdays, generate_bdays, is_bday, offset_bdays
-from .data_access import fetch_asset, fetch_indicator, fetch_projection
-from .data_analysis import calculate_spreads
+from .data_access import (
+    calculate_spreads,
+    fetch_asset,
+    fetch_indicator,
+    fetch_projection,
+)
 
 __all__ = [
     "__version__",

{pyield-0.7.7 → pyield-0.7.9}/pyield/data_access.py

@@ -3,14 +3,13 @@ import pandas as pd
 from . import futures as ft
 from . import indicators as it
 from . import projections as pr
+from . import spreads as sp
 from . import treasuries as tr
 from .utils import _normalize_date
 
 
 def fetch_asset(
-    asset_code: str,
-    reference_date: str | pd.Timestamp | None = None,
-    **kwargs,
+    asset_code: str, reference_date: str | pd.Timestamp | None = None
 ) -> pd.DataFrame:
     """
     Fetches data for a specified asset based on type and reference date.
@@ -24,6 +23,11 @@ def fetch_asset(
             - "DI1": One-day Interbank Deposit Futures (Futuro de DI) from B3.
             - "DDI": DI x U.S. Dollar Spread Futures (Futuro de Cupom Cambial) from B3.
             - "FRC": Forward Rate Agreement (FRA) from B3.
+            - "DAP": DI x IPCA Spread Futures.
+            - "DOL": U.S. Dollar Futures from B3.
+            - "WDO": Mini U.S. Dollar Futures from B3.
+            - "IND": Ibovespa Futures from B3.
+            - "WIN": Mini Ibovespa Futures from B3.
         reference_date (str | pd.Timestamp | None): The reference date for which data is
             fetched. Defaults to the last business day if None.
         **kwargs: Additional keyword arguments, specifically:
@@ -40,27 +44,28 @@ def fetch_asset(
         >>> fetch_asset('TRB', '2023-04-01')
         >>> fetch_asset('DI1', '2023-04-01', return_raw=True)
     """
-    return_raw = kwargs.get("return_raw", False)
+    SUPPORTED_BONDS = ["LTN", "LFT", "NTN-F", "NTN-B"]
+    SUPPORTED_FUTURES = ["DI1", "DDI", "FRC", "DAP", "DOL", "WDO", "IND", "WIN"]
+
     normalized_date = _normalize_date(reference_date)
 
-    if asset_code.lower() == "trb":
-        return tr.fetch_bonds(reference_date=normalized_date, return_raw=return_raw)
-    elif asset_code.lower() in ["ltn", "lft", "ntn-f", "ntn-b"]:
+    today = pd.Timestamp.today().normalize()
+    if normalized_date == today:
+        return ft.fetch_intraday_df(future_code=asset_code.upper())
+
+    if asset_code.upper() == "TRB":
+        return tr.fetch_bonds(reference_date=normalized_date)
+
+    if asset_code.upper() in SUPPORTED_BONDS:
         df = tr.fetch_bonds(reference_date=normalized_date)
         return df.query(f"BondType == '{asset_code.upper()}'")
 
-    elif asset_code.lower() == "di1":
-        today = pd.Timestamp.today().normalize()
-        if normalized_date == today:
-            return ft.fetch_last_di()
-        else:
-            return ft.fetch_past_di(trade_date=normalized_date, return_raw=return_raw)
-    elif asset_code.lower() == "ddi":
-        return ft.fetch_past_ddi(trade_date=normalized_date, return_raw=return_raw)
-    elif asset_code.lower() == "frc":
-        return ft.fetch_past_frc(trade_date=normalized_date, return_raw=return_raw)
-    else:
-        raise ValueError("Asset type not supported.")
+    if asset_code.upper() in SUPPORTED_FUTURES:
+        return ft.fetch_historical_df(
+            asset_code=asset_code.upper(), trade_date=normalized_date
+        )
+
+    raise ValueError("Asset type not supported.")
 
 
 def fetch_indicator(
@@ -99,13 +104,13 @@ def fetch_indicator(
     """
     normalized_date = _normalize_date(reference_date)
 
-    if indicator_code.lower() == "selic":
+    if indicator_code.upper() == "SELIC":
         return it.fetch_selic_target(reference_date=normalized_date)
-    elif indicator_code.lower() == "ipca":
+    elif indicator_code.upper() == "IPCA":
         return it.fetch_ipca_mr(reference_date=normalized_date)
-    elif indicator_code.lower() == "di":
+    elif indicator_code.upper() == "DI":
         return it.fetch_di(reference_date=normalized_date)
-    elif indicator_code.lower() == "vna_lft":
+    elif indicator_code.upper() == "VNA_LFT":
         return it.fetch_vna_selic(reference_date=normalized_date)
     else:
         raise ValueError("Indicator type not supported.")
@@ -142,7 +147,36 @@ def fetch_projection(projection_code: str) -> pr.IndicatorProjection:
         )
     """
 
-    if projection_code.lower() == "ipca_cm":
+    if projection_code.upper() == "IPCA_CM":
         return pr.fetch_current_month_ipca_projection()
     else:
         raise ValueError("Projection type not supported.")
+
+
+def calculate_spreads(
+    spread_type: str, reference_date: str | pd.Timestamp | None = None
+) -> pd.DataFrame:
+    """
+    Calculates spreads between assets based on the specified spread type.
+    If no reference date is provided, the function uses the previous business day.
+
+    Parameters:
+        spread_type (str): The type of spread to calculate. Available options are:
+            - "DI_vs_PRE": the spread between DI Futures and Treasury Pre-Fixed bonds.
+        reference_date (str | pd.Timestamp, optional): The reference date for the
+            spread calculation. If None or not provided, defaults to the previous
+            business day according to the Brazilian calendar.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the calculated spread in basis points.
+        The data is sorted by asset type and maturity/expiration date.
+
+    Raises:
+        ValueError: If an invalid spread type is provided.
+    """
+    # Normalize the reference date
+    normalized_date = _normalize_date(reference_date)
+    if spread_type.upper() == "DI_VS_PRE":
+        return sp.calculate_di_spreads(normalized_date)
+    else:
+        raise ValueError("Invalid spread type.")

pyield-0.7.9/pyield/futures/__init__.py

@@ -0,0 +1,4 @@
+from .historical import fetch_historical_df
+from .intraday import fetch_intraday_df
+
+__all__ = ["fetch_historical_df", "fetch_intraday_df"]

pyield-0.7.7/pyield/futures/common.py → pyield-0.7.9/pyield/futures/historical.py

@@ -5,26 +5,15 @@ import requests
 
 from .. import bday
 
-COLUMNS_MAPPING = {
-    "VENCTO": "ExpirationCode",
-    "CONTR. ABERT.(1)": "OpenContracts",  # At the start of the day
-    "CONTR. FECH.(2)": "OpenContractsEndSession",  # At the end of the day
-    "NÚM. NEGOC.": "TradeCount",
-    "CONTR. NEGOC.": "TradeVolume",
-    "VOL.": "FinancialVolume",
-    "AJUSTE": "SettlementPrice",
-    "AJUSTE ANTER. (3)": "PrevSettlementRate",
-    "AJUSTE CORRIG. (4)": "AdjSettlementRate",
-    "AJUSTE  DE REF.": "SettlementRate",  # FRC
-    "PREÇO MÍN.": "MinRate",
-    "PREÇO MÉD.": "AvgRate",
-    "PREÇO MÁX.": "MaxRate",
-    "PREÇO ABERTU.": "FirstRate",
-    "ÚLT. PREÇO": "CloseRate",
-    "VAR. PTOS.": "PointsVariation",
-    # Attention: bid/ask rates are inverted
-    "ÚLT.OF. COMPRA": "CloseAskRate",
-    "ÚLT.OF. VENDA": "CloseBidRate",
+COUNT_CONVENTIONS = {
+    "DAP": 252,
+    "DI1": 252,
+    "DDI": 360,
+    "FRC": None,
+    "DOL": None,
+    "WDO": None,
+    "IND": None,
+    "WIN": None,
 }
 
 
@@ -153,7 +142,33 @@ def get_old_expiration_date(
         return pd.NaT  # type: ignore
 
 
-def fetch_past_raw_df(asset_code: str, trade_date: pd.Timestamp) -> pd.DataFrame:
+def convert_prices_to_rates(
+    prices: pd.Series, days_to_expiration: pd.Series, count_convention: int
+) -> pd.Series:
+    """
+    Internal function to convert DI futures prices to rates.
+
+    Args:
+        prices (pd.Series): The futures prices to be converted.
+        days_to_expiration (pd.Series): The number of days to expiration for each price.
+        count_convention (int): The count convention for the DI futures contract.
+            Can be 252 business days or 360 calendar days.
+
+    Returns:
+        pd.Series: A pd.Series containing the futures rates.
+    """
+    if count_convention == 252:
+        rates = (100_000 / prices) ** (252 / days_to_expiration) - 1
+    elif count_convention == 360:
+        rates = (100_000 / prices - 1) * (360 / days_to_expiration)
+    else:
+        raise ValueError("Invalid count_convention. Must be 252 or 360.")
+
+    # Round to 5 (3 in %) dec. places (contract's current max. precision)
+    return rates.round(5)
+
+
+def fetch_raw_df(asset_code: str, trade_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.
@@ -199,60 +214,17 @@ def fetch_past_raw_df(asset_code: str, trade_date: pd.Timestamp) -> pd.DataFrame
     return df
 
 
-def fetch_last_raw_df(future_code: str) -> pd.DataFrame:
-    """
-    Fetch the latest data for a given future code from B3 derivatives quotation API.
-
-    Args:
-    future_code (str): The future code to fetch data for.
-
-    Returns:
-    pd.DataFrame: A DataFrame containing the normalized and cleaned data from the API.
-
-    Raises:
-    Exception: An exception is raised if the data fetch operation fails.
-    """
-
-    url = f"https://cotacao.b3.com.br/mds/api/v1/DerivativeQuotation/{future_code}"
-
-    try:
-        r = requests.get(url)
-        r.raise_for_status()  # Check for HTTP request errors
-    except requests.exceptions.RequestException:
-        raise Exception(f"Failed to fetch data for {future_code}.") from None
-
-    r.encoding = "utf-8"  # Explicitly set response encoding to utf-8 for consistency
+def _adjust_older_contracts_rates(df: pd.DataFrame, rate_cols: list) -> pd.DataFrame:
+    for col in rate_cols:
+        df[col] = convert_prices_to_rates(df[col], df["BDaysToExp"], 252)
 
-    # Normalize JSON response into a flat table
-    df = pd.json_normalize(r.json()["Scty"])
-
-    # Clean and reformat the DataFrame columns
-    df.columns = (df.columns
-        .str.replace("SctyQtn.", "")
-        .str.replace("asset.AsstSummry.", "")
-    )  # fmt: skip
-    df.drop(columns=["desc", "asset.code", "mkt.cd"], inplace=True)
-
-    # Convert maturity codes to datetime and drop rows with missing values
-    df["mtrtyCode"] = pd.to_datetime(df["mtrtyCode"], errors="coerce")
-    df.dropna(subset=["mtrtyCode"], inplace=True)
-
-    # Sort the DataFrame by maturity code and reset the index
-    df.sort_values("mtrtyCode", inplace=True, ignore_index=True)
-
-    # Get current date and time
-    now = pd.Timestamp.now().round("s")
-    # Subtract 15 minutes from the current time to account for API delay
-    trade_ts = now - pd.Timedelta(minutes=15)
-    df["TradeTimestamp"] = trade_ts
-
-    # Convert DataFrame to use nullable data types for better type consistency
-    df = df.convert_dtypes(dtype_backend="numpy_nullable")
+    # Invert low and high prices
+    df["MinRate"], df["MaxRate"] = df["MaxRate"], df["MinRate"]
 
     return df
 
 
-def rename_columns(df: pd.DataFrame):
+def rename_columns(df: pd.DataFrame) -> pd.DataFrame:
     all_columns = {
         "VENCTO": "ExpirationCode",
         "CONTR. ABERT.(1)": "OpenContracts",  # At the start of the day
@@ -274,13 +246,68 @@ def rename_columns(df: pd.DataFrame):
         "ÚLT.OF. COMPRA": "CloseAskRate",
         "ÚLT.OF. VENDA": "CloseBidRate",
     }
-    rename_dict = {}
-    for col in all_columns:
-        if col in df.columns:
-            rename_dict[col] = all_columns[col]
+    rename_dict = {c: all_columns[c] for c in all_columns if c in df.columns}
     return df.rename(columns=rename_dict)
 
 
+def process_df(
+    df: pd.DataFrame,
+    trade_date: pd.Timestamp,
+    asset_code: str,
+) -> pd.DataFrame:
+    df["TradeDate"] = trade_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"):
+        df["ExpirationDate"] = df["ExpirationCode"].apply(
+            get_old_expiration_date, args=(trade_date,)
+        )
+    else:
+        df["ExpirationDate"] = df["ExpirationCode"].apply(get_expiration_date)
+
+    df["DaysToExp"] = (df["ExpirationDate"] - trade_date).dt.days
+    # Convert to nullable integer, since it is the default type in the library
+    df["DaysToExp"] = df["DaysToExp"].astype(pd.Int64Dtype())
+    # Remove expired contracts
+    df.query("DaysToExp > 0", inplace=True)
+
+    df["BDaysToExp"] = bday.count_bdays(trade_date, df["ExpirationDate"])
+
+    # Columns where 0 means NaN
+    cols_with_nan = [col for col in df.columns if "Rate" in col]
+    if "SettlementPrice" in df.columns:
+        cols_with_nan.append("SettlementPrice")
+    # Replace 0 with NaN in these columns
+    df[cols_with_nan] = df[cols_with_nan].replace(0, pd.NA)
+
+    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":
+        df = _adjust_older_contracts_rates(df, rate_cols)
+    else:
+        # Remove % and round to 5 (3 in %) dec. places in rate columns
+        df[rate_cols] = df[rate_cols].div(100).round(5)
+
+    if COUNT_CONVENTIONS[asset_code] == 252:
+        df["SettlementRate"] = convert_prices_to_rates(
+            prices=df["SettlementPrice"],
+            days_to_expiration=df["BDaysToExp"],
+            count_convention=252,
+        )
+    elif COUNT_CONVENTIONS[asset_code] == 360:
+        df["SettlementRate"] = convert_prices_to_rates(
+            prices=df["SettlementPrice"],
+            days_to_expiration=df["DaysToExp"],
+            count_convention=360,
+        )
+
+    return df
+
+
 def reorder_columns(df: pd.DataFrame):
     all_columns = [
         "TradeDate",
@@ -305,8 +332,33 @@ def reorder_columns(df: pd.DataFrame):
         "CloseBidRate",
         "CloseRate",
     ]
-    reordered_columns = []
-    for col in all_columns:
-        if col in df.columns:
-            reordered_columns.append(col)
+    reordered_columns = [col for col in all_columns if col in df.columns]
     return df[reordered_columns]
+
+
+def fetch_historical_df(
+    asset_code: str,
+    trade_date: pd.Timestamp,
+) -> pd.DataFrame:
+    """
+    Fetchs the futures data for a given date from B3.
+
+    This function fetches and processes the futures data from B3 for a specific
+    trade date. It's the primary external interface for accessing futures 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.
+        count_convention (int): The count convention for the DI futures contract.
+            Can be 252 business days or 360 calendar days.
+
+    Returns:
+        pd.DataFrame: A Pandas pd.DataFrame containing processed futures data.
+    """
+    df_raw = fetch_raw_df(asset_code=asset_code, trade_date=trade_date)
+    if df_raw.empty:
+        return df_raw
+    df = rename_columns(df_raw)
+    df = process_df(df, trade_date, asset_code)
+    df = reorder_columns(df)
+    return df

pyield-0.7.9/pyield/futures/intraday.py

@@ -0,0 +1,107 @@
+import pandas as pd
+import requests
+
+
+def _fetch_raw_df(future_code: str) -> pd.DataFrame:
+    """
+    Fetch the latest data for a given future code from B3 derivatives quotation API.
+
+    Args:
+    future_code (str): The future code to fetch data for.
+
+    Returns:
+    pd.DataFrame: A DataFrame containing the normalized and cleaned data from the API.
+
+    Raises:
+    Exception: An exception is raised if the data fetch operation fails.
+    """
+
+    url = f"https://cotacao.b3.com.br/mds/api/v1/DerivativeQuotation/{future_code}"
+
+    try:
+        r = requests.get(url)
+        r.raise_for_status()  # Check for HTTP request errors
+    except requests.exceptions.RequestException:
+        raise Exception(f"Failed to fetch data for {future_code}.") from None
+
+    r.encoding = "utf-8"  # Explicitly set response encoding to utf-8 for consistency
+
+    if "Quotation not available" in r.text:
+        return pd.DataFrame()
+
+    # Normalize JSON response into a flat table
+    df = pd.json_normalize(r.json()["Scty"])
+
+    # Clean and reformat the DataFrame columns
+    df.columns = (df.columns
+        .str.replace("SctyQtn.", "")
+        .str.replace("asset.AsstSummry.", "")
+    )  # fmt: skip
+    df.drop(columns=["desc", "asset.code", "mkt.cd"], inplace=True)
+
+    # Convert maturity codes to datetime and drop rows with missing values
+    df["mtrtyCode"] = pd.to_datetime(df["mtrtyCode"], errors="coerce")
+    df.dropna(subset=["mtrtyCode"], inplace=True)
+
+    # Sort the DataFrame by maturity code and reset the index
+    df.sort_values("mtrtyCode", inplace=True, ignore_index=True)
+
+    # Get current date and time
+    now = pd.Timestamp.now().round("s")
+    # Subtract 15 minutes from the current time to account for API delay
+    trade_ts = now - pd.Timedelta(minutes=15)
+    df["TradeTimestamp"] = trade_ts
+
+    # Convert DataFrame to use nullable data types for better type consistency
+    df = df.convert_dtypes(dtype_backend="numpy_nullable")
+
+    return df
+
+
+def _process_raw_df(raw_df: pd.DataFrame) -> pd.DataFrame:
+    df = raw_df.copy()
+
+    # Columns to be renamed
+    all_columns = {
+        "TradeTimestamp": "TradeTimestamp",
+        "symb": "TickerSymbol",
+        "mtrtyCode": "ExpirationDate",
+        "BDaysToExp": "BDaysToExp",
+        "opnCtrcts": "OpenContracts",
+        "tradQty": "TradeCount",
+        "traddCtrctsQty": "TradeVolume",
+        "grssAmt": "FinancialVolume",
+        "prvsDayAdjstmntPric": "PrevSettlementRate",
+        "bottomLmtPric": "MinLimitRate",
+        "topLmtPric": "MaxLimitRate",
+        "opngPric": "OpenRate",
+        "minPric": "MinRate",
+        "avrgPric": "AvgRate",
+        "maxPric": "MaxRate",
+        "buyOffer.price": "CurrentAskRate",
+        "sellOffer.price": "CurrentBidRate",
+        "curPrc": "CurrentRate",
+    }
+    # Check which columns are present in the DataFrame before renaming
+    rename_dict = {c: all_columns[c] for c in all_columns if c in df.columns}
+    df = df.rename(columns=rename_dict)
+
+    # df["BDaysToExp"] = bd.count_bdays(df["TradeTimestamp"], df["ExpirationDate"])
+
+    # Remove percentage in all rate columns
+    rate_cols = [col for col in df.columns if "Rate" in col]
+    df[rate_cols] = df[rate_cols] / 100
+
+    # Reorder columns based on the order of the dictionary
+    return df[rename_dict.values()]
+
+
+def fetch_intraday_df(future_code: str) -> pd.DataFrame:
+    """
+    Fetch the latest DI futures data from B3.
+
+    Returns:
+        pd.DataFrame: A Pandas pd.DataFrame containing the latest DI futures data.
+    """
+    raw_df = _fetch_raw_df(future_code)
+    return _process_raw_df(raw_df)

pyield-0.7.9/pyield/spreads.py

@@ -0,0 +1,56 @@
+import pandas as pd
+
+from . import treasuries as tr
+from .futures import historical as fh
+
+# Constant for conversion to basis points
+BPS_CONVERSION_FACTOR = 10_000
+
+
+def calculate_di_spreads(reference_date: pd.Timestamp) -> pd.DataFrame:
+    """
+    Calculates the DI spread for Brazilian treasury bonds (LTN and NTN-F) based on
+    ANBIMA's indicative rates.
+
+    This function fetches the indicative rates for Brazilian treasury securities (LTN
+    and NTN-F bonds) and the DI futures rates for a specified reference date,
+    calculating the spread between these rates in basis points. If no reference date is
+    provided, the function uses the previous business day.
+
+    Parameters:
+        reference_date (str | pd.Timestamp, optional): The reference date for the DI
+            spread calculation.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the bond type, reference date, maturity
+            date, and the calculated DI spread in basis points. The data is sorted by
+            bond type and maturity date.
+    """
+    # Fetch DI rates for the reference date
+    df_di = fh.fetch_historical_df(asset_code="DI1", trade_date=reference_date)[
+        ["ExpirationDate", "SettlementRate"]
+    ]
+
+    # Renaming the columns to match the ANBIMA structure
+    df_di.rename(columns={"ExpirationDate": "MaturityDate"}, inplace=True)
+
+    # Adjusting maturity date to match bond data format
+    df_di["MaturityDate"] = df_di["MaturityDate"].dt.to_period("M").dt.to_timestamp()
+
+    # Fetch bond rates, filtering for LTN and NTN-F types
+    df_anbima = tr.fetch_bonds(reference_date, False)
+    df_anbima.query("BondType in ['LTN', 'NTN-F']", inplace=True)
+
+    # Merge bond and DI rates by maturity date to calculate spreads
+    df_final = pd.merge(df_anbima, df_di, how="left", on="MaturityDate")
+
+    # Calculate the DI spread as the difference between indicative and settlement rates
+    df_final["DISpread"] = df_final["IndicativeRate"] - df_final["SettlementRate"]
+
+    # Convert spread to basis points for clarity
+    df_final["DISpread"] = (BPS_CONVERSION_FACTOR * df_final["DISpread"]).round(2)
+
+    # Prepare and return the final sorted DataFrame
+    select_columns = ["BondType", "ReferenceDate", "MaturityDate", "DISpread"]
+    df_final = df_final[select_columns].copy()
+    return df_final.sort_values(["BondType", "MaturityDate"], ignore_index=True)

{pyield-0.7.7 → pyield-0.7.9}/pyield/treasuries.py

@@ -3,15 +3,10 @@ import io
 import pandas as pd
 import requests
 
-from . import futures as ft
-
 # URL Constants
 ANBIMA_NON_MEMBER_URL = "https://www.anbima.com.br/informacoes/merc-sec/arqs/"
 ANBIMA_MEMBER_URL = "http://www.anbima.associados.rtm/merc_sec/arqs/"
 
-# Constant for conversion to basis points
-BPS_CONVERSION_FACTOR = 10_000
-
 
 def _get_anbima_content(reference_date: pd.Timestamp) -> str:
     url_date = reference_date.strftime("%y%m%d")
@@ -128,50 +123,3 @@ def fetch_bonds(reference_date: pd.Timestamp, return_raw=False) -> pd.DataFrame:
         df = _process_raw_df(df)
 
     return df
-
-
-def calculate_di_spreads(reference_date: pd.Timestamp) -> pd.DataFrame:
-    """
-    Calculates the DI spread for Brazilian treasury bonds (LTN and NTN-F) based on
-    ANBIMA's indicative rates.
-
-    This function fetches the indicative rates for Brazilian treasury securities (LTN
-    and NTN-F bonds) and the DI futures rates for a specified reference date,
-    calculating the spread between these rates in basis points. If no reference date is
-    provided, the function uses the previous business day.
-
-    Parameters:
-        reference_date (str | pd.Timestamp, optional): The reference date for the DI
-            spread calculation.
-
-    Returns:
-        pd.DataFrame: A DataFrame containing the bond type, reference date, maturity
-            date, and the calculated DI spread in basis points. The data is sorted by
-            bond type and maturity date.
-    """
-    # Fetch DI rates and adjust the maturity date format for compatibility
-    df_di = ft.fetch_past_di(reference_date)[["ExpirationDate", "SettlementRate"]]
-
-    # Renaming the columns to match the ANBIMA structure
-    df_di.rename(columns={"ExpirationDate": "MaturityDate"}, inplace=True)
-
-    # Adjusting maturity date to match bond data format
-    df_di["MaturityDate"] = df_di["MaturityDate"].dt.to_period("M").dt.to_timestamp()
-
-    # Fetch bond rates, filtering for LTN and NTN-F types
-    df_anbima = fetch_bonds(reference_date, False)
-    df_anbima.query("BondType in ['LTN', 'NTN-F']", inplace=True)
-
-    # Merge bond and DI rates by maturity date to calculate spreads
-    df_final = pd.merge(df_anbima, df_di, how="left", on="MaturityDate")
-
-    # Calculate the DI spread as the difference between indicative and settlement rates
-    df_final["DISpread"] = df_final["IndicativeRate"] - df_final["SettlementRate"]
-
-    # Convert spread to basis points for clarity
-    df_final["DISpread"] = (BPS_CONVERSION_FACTOR * df_final["DISpread"]).round(2)
-
-    # Prepare and return the final sorted DataFrame
-    select_columns = ["BondType", "ReferenceDate", "MaturityDate", "DISpread"]
-    df_final = df_final[select_columns].copy()
-    return df_final.sort_values(["BondType", "MaturityDate"], ignore_index=True)

{pyield-0.7.7 → pyield-0.7.9}/pyproject.toml

@@ -23,16 +23,16 @@ classifiers = [
     "Topic :: Office/Business :: Financial :: Investment",
 ]
 dependencies = [
-    "requests",
     "pandas>=2.0.0",
     "numpy",
     "beautifulsoup4",
     "html5lib",
     "lxml",
     "python-calamine>=0.2.0",
+    "requests>=2.31.0",
 ]
 dynamic = []
-version = "0.7.7"
+version = "0.7.9"
 
 [project.license]
 file = "LICENSE"

pyield-0.7.9/tests/test_futures.py

@@ -0,0 +1,38 @@
+import pyield as yd
+
+
+def test_settlement_rate_with_old_holiday_list():
+    settlement_rates = {
+        "DI1N27": 0.09809,
+        "DI1F33": 0.10368,
+    }
+
+    # 22-12-2023 is before the new holiday calendar
+    df = yd.fetch_asset(asset_code="DI1", reference_date="2023-12-22")
+    tickers = list(settlement_rates.keys())  # noqa: F841
+    result = df.query("TickerSymbol in @tickers")["SettlementRate"].to_list()
+    assert result == list(settlement_rates.values())
+
+
+def test_settlement_rates_with_current_holiday_list():
+    settlement_rates = {
+        "DI1F24": 0.11644,
+        "DI1J24": 0.11300,
+        "DI1N24": 0.10786,
+        "DI1V24": 0.10321,
+        "DI1F25": 0.10031,
+        "DI1J25": 0.09852,
+        "DI1N25": 0.09715,
+        "DI1V25": 0.09651,
+        "DI1F26": 0.09583,
+        "DI1N26": 0.09631,
+        "DI1F27": 0.09683,
+        "DI1N27": 0.09794,
+        "DI1F29": 0.10042,
+        "DI1F31": 0.10240,
+        "DI1F33": 0.10331,
+    }
+    df = yd.fetch_asset(asset_code="DI1", reference_date="2023-12-26")
+    tickers = list(settlement_rates.keys())  # noqa: F841
+    results = df.query("TickerSymbol in @tickers")["SettlementRate"].to_list()
+    assert results == list(settlement_rates.values())

pyield-0.7.7/pyield/futures/di_xml.py → pyield-0.7.9/tests/xml.py

@@ -7,8 +7,8 @@ import requests
 from lxml import etree
 from pandas import DataFrame, Timestamp
 
-from .. import bday
-from . import common as cm
+from ..pyield import bday
+from ..pyield.futures import historical as ht
 
 
 def _get_file_from_url(trade_date: Timestamp, source_type: str) -> io.BytesIO:
@@ -206,7 +206,7 @@ def _standardize_column_names(df: DataFrame) -> DataFrame:
         "TradAvrgPric": "AvgRate",
         "MaxPric": "MaxRate",
         "FrstPric": "FirstRate",
-        "LastPric": "LastRate",
+        "LastPric": "CloseRate",
         "AdjstdQtTax": "SettlementRate",
         # "RglrTxsQty"
         # "RglrTraddCtrcts"
@@ -229,7 +229,7 @@ def _process_di_df(df_raw: DataFrame) -> DataFrame:
     # Convert to datetime64[ns] since it is pandas default type for timestamps
     df["TradDt"] = df["TradDt"].astype("datetime64[ns]")
 
-    expiration = df["TckrSymb"].str[3:].apply(cm.get_expiration_date)
+    expiration = df["TckrSymb"].str[3:].apply(ht.get_expiration_date)
     df.insert(2, "ExpirationDate", expiration)
 
     business_days = bday.count_bdays(df["TradDt"], df["ExpirationDate"])

pyield-0.7.7/pyield/__about__.py

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

pyield-0.7.7/pyield/data_analysis.py

@@ -1,33 +0,0 @@
-import pandas as pd
-
-from . import treasuries as tr
-from .utils import _normalize_date
-
-
-def calculate_spreads(
-    spread_type: str, reference_date: str | pd.Timestamp | None = None
-) -> pd.DataFrame:
-    """
-    Calculates spreads between assets based on the specified spread type.
-    If no reference date is provided, the function uses the previous business day.
-
-    Parameters:
-        spread_type (str): The type of spread to calculate. Available options are:
-            - "DI_vs_PRE": the spread between DI Futures and Treasury Pre-Fixed bonds.
-        reference_date (str | pd.Timestamp, optional): The reference date for the
-            spread calculation. If None or not provided, defaults to the previous
-            business day according to the Brazilian calendar.
-
-    Returns:
-        pd.DataFrame: A DataFrame containing the calculated spread in basis points.
-        The data is sorted by asset type and maturity/expiration date.
-
-    Raises:
-        ValueError: If an invalid spread type is provided.
-    """
-    # Normalize the reference date
-    normalized_date = _normalize_date(reference_date)
-    if spread_type.lower() == "di_vs_pre":
-        return tr.calculate_di_spreads(normalized_date)
-    else:
-        raise ValueError("Invalid spread type.")

pyield-0.7.7/pyield/futures/__init__.py

@@ -1,13 +0,0 @@
-from .common import get_expiration_date, get_old_expiration_date
-from .ddi import fetch_past_ddi
-from .di import fetch_last_di, fetch_past_di
-from .frc import fetch_past_frc
-
-__all__ = [
-    "fetch_past_di",
-    "fetch_last_di",
-    "fetch_past_ddi",
-    "fetch_past_frc",
-    "get_expiration_date",
-    "get_old_expiration_date",
-]

pyield-0.7.7/pyield/futures/ddi.py

@@ -1,101 +0,0 @@
-import pandas as pd
-
-from . import common as cm
-
-
-def _convert_prices_to_rates(prices: pd.Series, n_days: pd.Series) -> pd.Series:
-    """
-    Internal function to convert DDI futures prices to rates.
-
-    Args:
-        prices (pd.Series): A pd.Series containing DDI futures prices.
-        bd (pd.Series): A serie containing the number of days to expiration.
-
-    Returns:
-        pd.Series: A pd.Series containing DDI futures rates.
-    """
-    rates = (100_000 / prices - 1) * (360 / n_days)
-    # Round to 5 (3 in %) dec. places (contract's current max. precision)
-    return rates.round(5)
-
-
-def _process_raw_df(df: pd.DataFrame, trade_date: pd.Timestamp) -> pd.DataFrame:
-    """
-    Internal function to process and transform raw DI futures data.
-
-    Args:
-        df (pd.DataFrame): the raw DI DataFrame.
-        trade_date: a datetime-like object representing the trade date.
-
-    Returns:
-        pd.DataFrame: Processed and transformed data as a Pandas pd.DataFrame.
-    """
-    df = cm.rename_columns(df)
-
-    df["TradeDate"] = trade_date
-    # Convert to datetime64[ns] since it is pandas default type for timestamps
-    df["TradeDate"] = df["TradeDate"].astype("datetime64[ns]")
-
-    # Contract code format was changed in 22/05/2006
-    if trade_date < pd.Timestamp("2006-05-22"):
-        df["ExpirationDate"] = df["ExpirationCode"].apply(
-            cm.get_old_expiration_date, args=(trade_date,)
-        )
-    else:
-        df["ExpirationDate"] = df["ExpirationCode"].apply(cm.get_expiration_date)
-
-    df["DaysToExp"] = (df["ExpirationDate"] - trade_date).dt.days
-    # Convert to nullable integer, since other columns use this data type
-    df["DaysToExp"] = df["DaysToExp"].astype(pd.Int64Dtype())
-
-    # Remove expired contracts
-    df.query("DaysToExp > 0", inplace=True)
-
-    # Columns where 0 means NaN
-    rate_cols = [col for col in df.columns if "Rate" in col]
-    cols_with_nan = rate_cols + ["SettlementPrice"]
-    # Replace 0 with NaN in these columns
-    df[cols_with_nan] = df[cols_with_nan].replace(0, pd.NA)
-
-    df[rate_cols] = df[rate_cols].div(100).round(5)
-
-    # Calculate SettlementRate
-    df["SettlementRate"] = _convert_prices_to_rates(
-        df["SettlementPrice"], df["DaysToExp"]
-    )
-
-    df["TickerSymbol"] = "DI1" + df["ExpirationCode"]
-
-    # Filter and order columns
-    df = cm.reorder_columns(df)
-
-    return df
-
-
-def fetch_past_ddi(trade_date: pd.Timestamp, return_raw: bool = False) -> pd.DataFrame:
-    """
-    Fetchs the DDI futures data for a given date from B3.
-
-    This function fetches and processes the DI futures data from B3 for a specific
-    trade date. It's the primary external interface for accessing DI data.
-
-    Args:
-        trade_date (pd.Timestamp): The trade date to fetch the DI futures data.
-        raw (bool): If True, returns the raw data as a Pandas pd.DataFrame.
-            Defaults to False.
-
-    Returns:
-        pd.DataFrame: A Pandas pd.DataFrame containing processed DI futures data.
-
-    Examples:
-        >>> from pyield.futures import di
-        >>> di.fetch_ddi(pd.Timestamp("2021-01-04"))
-
-    Notes:
-        - DaysToExp: number of business days to ExpirationDate.
-        - OpenContracts: number of open contracts at the start of the trading day.
-    """
-    df_raw = cm.fetch_past_raw_df(asset_code="DDI", trade_date=trade_date)
-    if return_raw or df_raw.empty:
-        return df_raw
-    return _process_raw_df(df_raw, trade_date)

pyield-0.7.7/pyield/futures/di.py

@@ -1,160 +0,0 @@
-import pandas as pd
-
-from .. import bday as bd
-from . import common as cm
-
-
-def _convert_prices_to_rates(prices: pd.Series, bd: pd.Series) -> pd.Series:
-    """
-    Internal function to convert DI futures prices to rates.
-
-    Args:
-        prices (pd.Series): A pd.Series containing DI futures prices.
-        bd (pd.Series): A serie containing the number of business days to expiration.
-
-    Returns:
-        pd.Series: A pd.Series containing DI futures rates.
-    """
-    rates = (100_000 / prices) ** (252 / bd) - 1
-
-    # Round to 5 (3 in %) dec. places (contract's current max. precision)
-    return rates.round(5)
-
-
-def _adjust_older_contracts_rates(df: pd.DataFrame, rate_cols: list) -> pd.DataFrame:
-    for col in rate_cols:
-        df[col] = _convert_prices_to_rates(df[col], df["BDaysToExp"])
-
-    # Invert low and high prices
-    df["MinRate"], df["MaxRate"] = df["MaxRate"], df["MinRate"]
-
-    return df
-
-
-def _process_past_raw_df(df: pd.DataFrame, trade_date: pd.Timestamp) -> pd.DataFrame:
-    """
-    Internal function to process and transform raw DI futures data.
-
-    Args:
-        df (pd.DataFrame): the raw DI DataFrame.
-        trade_date: a datetime-like object representing the trade date.
-
-    Returns:
-        pd.DataFrame: Processed and transformed data as a Pandas pd.DataFrame.
-    """
-    df = cm.rename_columns(df)
-
-    df["TradeDate"] = trade_date
-    # Convert to datetime64[ns] since it is pandas default type for timestamps
-    df["TradeDate"] = df["TradeDate"].astype("datetime64[ns]")
-
-    # Contract code format was changed in 22/05/2006
-    if trade_date < pd.Timestamp("2006-05-22"):
-        df["ExpirationDate"] = df["ExpirationCode"].apply(
-            cm.get_old_expiration_date, args=(trade_date,)
-        )
-    else:
-        df["ExpirationDate"] = df["ExpirationCode"].apply(cm.get_expiration_date)
-
-    df["BDaysToExp"] = bd.count_bdays(trade_date, df["ExpirationDate"])
-
-    # Remove expired contracts
-    df.query("BDaysToExp > 0", inplace=True)
-
-    # Columns where 0 means NaN
-    rate_cols = [col for col in df.columns if "Rate" in col]
-    cols_with_nan = rate_cols + ["SettlementPrice"]
-    # Replace 0 with NaN in these columns
-    df[cols_with_nan] = df[cols_with_nan].replace(0, pd.NA)
-
-    # Prior to 17/01/2002 (inclusive), prices were not converted to rates
-    if trade_date > pd.Timestamp("2002-01-17"):
-        # Remove % and round to 5 (3 in %) dec. places in rate columns
-        df[rate_cols] = df[rate_cols].div(100).round(5)
-    else:
-        df = _adjust_older_contracts_rates(df, rate_cols)
-
-    # Calculate SettlementRate
-    df["SettlementRate"] = _convert_prices_to_rates(
-        df["SettlementPrice"], df["BDaysToExp"]
-    )
-
-    df["TickerSymbol"] = "DI1" + df["ExpirationCode"]
-
-    # Filter and order columns
-    df = cm.reorder_columns(df)
-    return df
-
-
-def _process_last_raw_di_df(raw_df: pd.DataFrame) -> pd.DataFrame:
-    df = raw_df.copy()
-
-    # Columns to be renamed
-    rename_columns = {
-        "TradeTimestamp": "TradeTimestamp",
-        "symb": "TickerSymbol",
-        "mtrtyCode": "ExpirationDate",
-        "BDaysToExp": "BDaysToExp",
-        "opnCtrcts": "OpenContracts",
-        "tradQty": "TradeCount",
-        "traddCtrctsQty": "TradeVolume",
-        "grssAmt": "FinancialVolume",
-        "prvsDayAdjstmntPric": "PrevSettlementRate",
-        "bottomLmtPric": "MinLimitRate",
-        "topLmtPric": "MaxLimitRate",
-        "opngPric": "OpenRate",
-        "minPric": "MinRate",
-        "avrgPric": "AvgRate",
-        "maxPric": "MaxRate",
-        "buyOffer.price": "LastAskRate",
-        "sellOffer.price": "LastBidRate",
-        "curPrc": "LastRate",
-    }
-    # Rename columns
-    df = df.rename(columns=rename_columns)
-
-    df["BDaysToExp"] = bd.count_bdays(df["TradeTimestamp"], df["ExpirationDate"])
-
-    # Remove percentage in all rate columns
-    rate_cols = [col for col in df.columns if "Rate" in col]
-    df[rate_cols] = df[rate_cols] / 100
-
-    # Reorder columns based on the order of the dictionary
-    return df[rename_columns.values()]
-
-
-def fetch_last_di() -> pd.DataFrame:
-    """
-    Fetch the latest DI futures data from B3.
-
-    Returns:
-        pd.DataFrame: A Pandas pd.DataFrame containing the latest DI futures data.
-    """
-    raw_df = cm.fetch_last_raw_df(future_code="DI1")
-    return _process_last_raw_di_df(raw_df)
-
-
-def fetch_past_di(trade_date: pd.Timestamp, return_raw: bool = False) -> pd.DataFrame:
-    """
-    Fetchs the DI futures data for a given date from B3.
-
-    This function fetches and processes the DI futures data from B3 for a specific
-    trade date. It's the primary external interface for accessing DI data. If the data
-    is not available, an empty DataFrame is returned.
-
-    Args:
-        trade_date (pd.Timestamp): The trade date to fetch the DI futures data.
-        return_raw (bool): If True, returns the raw data as a Pandas pd.DataFrame.
-            Defaults to False.
-
-    Returns:
-        pd.DataFrame: A Pandas pd.DataFrame containing processed DI futures data.
-
-    Notes:
-        - BDaysToExp: number of business days to ExpirationDate.
-        - OpenContracts: number of open contracts at the start of the trading day.
-    """
-    df_raw = cm.fetch_past_raw_df(asset_code="DI1", trade_date=trade_date)
-    if return_raw or df_raw.empty:
-        return df_raw
-    return _process_past_raw_df(df_raw, trade_date)

pyield-0.7.7/pyield/futures/frc.py

@@ -1,61 +0,0 @@
-import pandas as pd
-
-from . import common as cm
-
-
-def _process_past_data(df: pd.DataFrame, trade_date: pd.Timestamp) -> pd.DataFrame:
-    """
-    Internal function to process and transform raw DI futures data.
-
-    Args:
-        df (pd.DataFrame): the raw DI DataFrame.
-        trade_date: a datetime-like object representing the trade date.
-
-    Returns:
-        pd.DataFrame: Processed and transformed data as a Pandas pd.DataFrame.
-    """
-    df = cm.rename_columns(df)
-
-    df["TradeDate"] = trade_date
-    # Convert to datetime64[ns] since it is pandas default type for timestamps
-    df["TradeDate"] = df["TradeDate"].astype("datetime64[ns]")
-
-    # Contract code format was changed in 22/05/2006
-    if trade_date < pd.Timestamp("2006-05-22"):
-        df["ExpirationDate"] = df["ExpirationCode"].apply(
-            cm.get_old_expiration_date, args=(trade_date,)
-        )
-    else:
-        df["ExpirationDate"] = df["ExpirationCode"].apply(cm.get_expiration_date)
-
-    # Replace 0 values in rate columns with pd.NA and remove percentage
-    rate_cols = [col for col in df.columns if "Rate" in col]
-    # Round to 5 decimal places (3 in %) since it is the contract's precision
-    df[rate_cols] = df[rate_cols].replace(0, pd.NA).div(100).round(5)
-
-    df["TickerSymbol"] = "FRC" + df["ExpirationCode"]
-
-    # Filter and order columns
-    df = cm.reorder_columns(df)
-    return df
-
-
-def fetch_past_frc(trade_date: pd.Timestamp, return_raw: bool = False) -> pd.DataFrame:
-    """
-    Fetchs the DI futures data for a given date from B3.
-
-    This function fetches and processes the DI futures data from B3 for a specific
-    trade date. It's the primary external interface for accessing DI data.
-
-    Args:
-        trade_date (pd.Timestamp): The trade date to fetch the DI futures data.
-        raw (bool): If True, returns the raw data as a Pandas pd.DataFrame.
-            Defaults to False.
-
-    Returns:
-        pd.DataFrame: A Pandas pd.DataFrame containing processed DI futures data.
-    """
-    df_raw = cm.fetch_past_raw_df(asset_code="FRC", trade_date=trade_date)
-    if return_raw or df_raw.empty:
-        return df_raw
-    return _process_past_data(df_raw, trade_date)

pyield-0.7.7/tests/test_futures.py

@@ -1,80 +0,0 @@
-import pandas as pd
-
-from pyield import futures as ft
-
-
-def test_valid_old_contract_code1():
-    expiration_code = "JAN3"  # Valid contract code
-    trade_date = pd.Timestamp("2001-05-21")
-    result = ft.get_old_expiration_date(expiration_code, trade_date)
-    contract_expiration = pd.Timestamp("2003-01-02")
-    assert result == contract_expiration
-
-
-def test_valid_old_contract_code2():
-    expiration_code = "JAN3"  # Valid contract code
-    trade_date = pd.Timestamp("1990-01-01")
-    result = ft.get_old_expiration_date(expiration_code, trade_date)
-    contract_expiration = pd.Timestamp("1993-01-04")
-    assert result == contract_expiration
-
-
-def test_invalid_old_contract_code():
-    expiration_code = "J3"  # Invalid contract code
-    trade_date = pd.Timestamp("2001-01-02")
-    # Must return NaT
-    result = ft.get_old_expiration_date(expiration_code, trade_date)
-    assert pd.isnull(result)
-
-
-def test_new_contract_code():
-    expiration_code = "F23"  # Valid contract code
-    result = ft.get_expiration_date(expiration_code)
-    contract_expiration = pd.Timestamp("2023-01-02")
-    assert result == contract_expiration
-
-
-def test_settlement_rate_with_old_holiday_list():
-    settlement_rates = {
-        "DI1N27": 0.09809,
-        "DI1F33": 0.10368,
-    }
-
-    # 22-12-2023 is before the new holiday calendar
-    test_date = pd.Timestamp("2023-12-22")
-    df = ft.fetch_past_di(trade_date=test_date)
-    tickers = list(settlement_rates.keys())  # noqa: F841
-    result = df.query("TickerSymbol in @tickers")["SettlementRate"].to_list()
-    assert result == list(settlement_rates.values())
-
-
-def test_settlement_rates_with_current_holiday_list():
-    settlement_rates = {
-        "DI1F24": 0.11644,
-        "DI1J24": 0.11300,
-        "DI1N24": 0.10786,
-        "DI1V24": 0.10321,
-        "DI1F25": 0.10031,
-        "DI1J25": 0.09852,
-        "DI1N25": 0.09715,
-        "DI1V25": 0.09651,
-        "DI1F26": 0.09583,
-        "DI1N26": 0.09631,
-        "DI1F27": 0.09683,
-        "DI1N27": 0.09794,
-        "DI1F29": 0.10042,
-        "DI1F31": 0.10240,
-        "DI1F33": 0.10331,
-    }
-    test_date = pd.Timestamp("2023-12-26")
-    df = ft.fetch_past_di(trade_date=test_date)
-    tickers = list(settlement_rates.keys())  # noqa: F841
-    results = df.query("TickerSymbol in @tickers")["SettlementRate"].to_list()
-    assert results == list(settlement_rates.values())
-
-
-def test_non_business_day():
-    non_business_day = pd.Timestamp("2023-12-24")
-    # Test if it an empty DataFrame is returned
-    df = ft.fetch_past_di(trade_date=non_business_day)
-    assert df.empty