PYield 0.7.8__tar.gz → 0.7.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PYield
-Version: 0.7.8
+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>

pyield-0.7.9/pyield/__about__.py

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

{pyield-0.7.8 → 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.8 → pyield-0.7.9}/pyield/data_access.py

@@ -1,17 +1,15 @@
 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 .futures import historical as fh
-from .futures import intraday as fi
 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.
@@ -25,7 +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
+            - "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:
@@ -42,31 +44,26 @@ 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)
 
     today = pd.Timestamp.today().normalize()
     if normalized_date == today:
-        return fi.fetch_intraday(future_code=asset_code.upper())
+        return ft.fetch_intraday_df(future_code=asset_code.upper())
 
-    if asset_code.lower() == "trb":
-        return tr.fetch_bonds(reference_date=normalized_date, return_raw=return_raw)
+    if asset_code.upper() == "TRB":
+        return tr.fetch_bonds(reference_date=normalized_date)
 
-    if asset_code.lower() in ["ltn", "lft", "ntn-f", "ntn-b"]:
+    if asset_code.upper() in SUPPORTED_BONDS:
         df = tr.fetch_bonds(reference_date=normalized_date)
         return df.query(f"BondType == '{asset_code.upper()}'")
 
-    if asset_code.lower() == "di1":
-        return fh.fetch_di(trade_date=normalized_date, return_raw=return_raw)
-
-    if asset_code.lower() == "ddi":
-        return fh.fetch_ddi(trade_date=normalized_date, return_raw=return_raw)
-
-    if asset_code.lower() == "frc":
-        return fh.fetch_frc(trade_date=normalized_date, return_raw=return_raw)
-
-    if asset_code.lower() == "dap":
-        return fh.fetch_dap(trade_date=normalized_date, return_raw=return_raw)
+    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.")
 
@@ -107,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.")
@@ -150,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.8/pyield/futures/historical/common.py → pyield-0.7.9/pyield/futures/historical.py

@@ -3,7 +3,18 @@ import io
 import pandas as pd
 import requests
 
-from ... import bday
+from .. import bday
+
+COUNT_CONVENTIONS = {
+    "DAP": 252,
+    "DI1": 252,
+    "DDI": 360,
+    "FRC": None,
+    "DOL": None,
+    "WDO": None,
+    "IND": None,
+    "WIN": None,
+}
 
 
 def get_expiration_date(expiration_code: str) -> pd.Timestamp:
@@ -141,12 +152,17 @@ def convert_prices_to_rates(
         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.
-            Normally, it is 252 business days or 360 calendar days.
+            Can be 252 business days or 360 calendar days.
 
     Returns:
         pd.Series: A pd.Series containing the futures rates.
     """
-    rates = (100_000 / prices) ** (count_convention / days_to_expiration) - 1
+    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)
@@ -198,6 +214,16 @@ def fetch_raw_df(asset_code: str, trade_date: pd.Timestamp) -> pd.DataFrame:
     return df
 
 
+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)
+
+    # Invert low and high prices
+    df["MinRate"], df["MaxRate"] = df["MaxRate"], df["MinRate"]
+
+    return df
+
+
 def rename_columns(df: pd.DataFrame) -> pd.DataFrame:
     all_columns = {
         "VENCTO": "ExpirationCode",
@@ -224,11 +250,11 @@ def rename_columns(df: pd.DataFrame) -> pd.DataFrame:
     return df.rename(columns=rename_dict)
 
 
-def process_raw_df(
-    df: pd.DataFrame, trade_date: pd.Timestamp, asset_code: str
+def process_df(
+    df: pd.DataFrame,
+    trade_date: pd.Timestamp,
+    asset_code: str,
 ) -> pd.DataFrame:
-    df = 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]")
@@ -243,6 +269,14 @@ def process_raw_df(
     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:
@@ -250,6 +284,27 @@ def process_raw_df(
     # 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
 
 
@@ -279,3 +334,31 @@ def reorder_columns(df: pd.DataFrame):
     ]
     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.8/pyield/futures/intraday/trading_data.py → pyield-0.7.9/pyield/futures/intraday.py

@@ -96,7 +96,7 @@ def _process_raw_df(raw_df: pd.DataFrame) -> pd.DataFrame:
     return df[rename_dict.values()]
 
 
-def fetch_intraday(future_code: str) -> pd.DataFrame:
+def fetch_intraday_df(future_code: str) -> pd.DataFrame:
     """
     Fetch the latest DI futures data from B3.
 

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.8 → pyield-0.7.9}/pyield/treasuries.py

@@ -3,15 +3,10 @@ import io
 import pandas as pd
 import requests
 
-from .futures import historical as fh
-
 # 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 = fh.fetch_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.8 → pyield-0.7.9}/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
     "requests>=2.31.0",
 ]
 dynamic = []
-version = "0.7.8"
+version = "0.7.9"
 
 [project.license]
 file = "LICENSE"

pyield-0.7.8/pyield/futures/historical/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:
@@ -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.8/pyield/__about__.py

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

pyield-0.7.8/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.8/pyield/futures/historical/__init__.py

@@ -1,6 +0,0 @@
-from .dap import fetch_dap
-from .ddi import fetch_ddi
-from .di import fetch_di
-from .frc import fetch_frc
-
-__all__ = ["fetch_di", "fetch_ddi", "fetch_frc", "fetch_dap"]

pyield-0.7.8/pyield/futures/historical/dap.py

@@ -1,62 +0,0 @@
-import pandas as pd
-
-from ... import bday as bd
-from . import common as cm
-
-
-def _process_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["BDaysToExp"] = bd.count_bdays(trade_date, df["ExpirationDate"])
-
-    # Remove expired contracts
-    df.query("BDaysToExp > 0", inplace=True)
-
-    rate_cols = [col for col in df.columns if "Rate" in col]
-    # Remove % and round to 5 (3 in %) dec. places in rate columns
-    df[rate_cols] = df[rate_cols].div(100).round(5)
-
-    # Calculate SettlementRate
-    df["SettlementRate"] = cm.convert_prices_to_rates(
-        prices=df["SettlementPrice"],
-        days_to_expiration=df["BDaysToExp"],
-        count_convention=252,
-    )
-
-    return df
-
-
-def fetch_dap(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_raw_df(asset_code="DI1", trade_date=trade_date)
-    if return_raw or df_raw.empty:
-        return df_raw
-    df = cm.process_raw_df(df_raw, trade_date, asset_code="DI1")
-    df = _process_df(df, trade_date)
-    return cm.reorder_columns(df)

pyield-0.7.8/pyield/futures/historical/ddi.py

@@ -1,80 +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_ddi_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["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)
-
-    # Columns where 0 means NaN
-    rate_cols = [col for col in df.columns if "Rate" in col]
-    df[rate_cols] = df[rate_cols].div(100).round(5)
-
-    # Calculate SettlementRate
-    df["SettlementRate"] = _convert_prices_to_rates(
-        df["SettlementPrice"], df["DaysToExp"]
-    )
-
-    return df
-
-
-def fetch_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_raw_df(asset_code="DDI", trade_date=trade_date)
-    if return_raw or df_raw.empty:
-        return df_raw
-    df = cm.process_raw_df(df_raw, trade_date, asset_code="DDI")
-    df = _process_ddi_df(df, trade_date)
-    return cm.reorder_columns(df)

pyield-0.7.8/pyield/futures/historical/di.py

@@ -1,91 +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_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["BDaysToExp"] = bd.count_bdays(trade_date, df["ExpirationDate"])
-
-    # Remove expired contracts
-    df.query("BDaysToExp > 0", inplace=True)
-
-    rate_cols = [col for col in df.columns if "Rate" in col]
-    # 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"]
-    )
-
-    return df
-
-
-def fetch_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_raw_df(asset_code="DI1", trade_date=trade_date)
-    if return_raw or df_raw.empty:
-        return df_raw
-    df = cm.process_raw_df(df_raw, trade_date, asset_code="DI1")
-    df = _process_df(df, trade_date)
-    return cm.reorder_columns(df)

pyield-0.7.8/pyield/futures/historical/frc.py

@@ -1,60 +0,0 @@
-import pandas as pd
-
-from . import common as cm
-
-
-def _process_frc_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)
-
-    # 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)
-
-    return df
-
-
-def fetch_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_raw_df(asset_code="FRC", trade_date=trade_date)
-    if return_raw or df_raw.empty:
-        return df_raw
-    # Filter and order columns
-    df = cm.process_raw_df(df_raw, trade_date, asset_code="FRC")
-    df = _process_frc_df(df, trade_date)
-    return cm.reorder_columns(df)

pyield-0.7.8/pyield/futures/intraday/__init__.py

@@ -1,3 +0,0 @@
-from .trading_data import fetch_intraday
-
-__all__ = ["fetch_intraday"]