PYield 0.12.0__tar.gz → 0.12.2__tar.gz

{pyield-0.12.0 → pyield-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PYield
-Version: 0.12.0
+Version: 0.12.2
 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.12.2/pyield/__about__.py

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

{pyield-0.12.0 → pyield-0.12.2}/pyield/bonds/ntnf.py

@@ -321,43 +321,86 @@ def gross_di_spreads(reference_date: str | pd.Timestamp) -> pd.Series:
     return df["DISpread"]
 
 
-def net_di_spread(
-    reference_date: str | pd.Timestamp,
+def net_di_spread(  # noqa
+    settlement_date: str | pd.Timestamp,
     maturity_date: str | pd.Timestamp,
+    ytm: float,
+    di_rates: list[float] | pd.Series,
+    di_expirations: list[pd.Timestamp] | pd.Series,
+    initial_guess: float | None = None,
 ) -> float:
-    reference_date = dc.convert_date(reference_date)
-    maturity_date = dc.convert_date(maturity_date)
-    settlement_date = bday.offset(reference_date, 0)
+    """
+    Calculate the net DI spread for a bond given the YTM and the DI rates.
+
+    This function determines the spread over the DI curve that equates the present value
+    of the bond's cash flows to its market price. It interpolates the DI rates to match
+    the bond's cash flow payment dates and uses the Brent method to find the spread
+    (in bps) that zeroes the difference between the bond's market price and its
+    discounted cash flows.
+
+    Parameters:
+    ----------
+    settlement_date : pd.Timestamp
+        The date on which the bond is settled.
+    maturity_date : pd.Timestamp
+        The date on which the bond matures.
+    ytm : float
+        The yield to maturity of the bond.
+    di_rates : list[float]
+        A list of DI rates corresponding to the DI expirations.
+    di_expirations : list[pd.Timestamp]
+        A list of DI expiration dates.
 
-    # Fetch DI rates for the reference date
-    df_di = di_data.settlement_rates(reference_date, adjust_exp_date=True)
+    Returns:
+    -------
+    float
+        The net DI spread in basis points. Returns NaN if a solution cannot be found.
+    """
+
+    # Create an interpolator for the DI rates using the flat-forward method
+    settlement_date = dc.convert_date(settlement_date)
+    maturity_date = dc.convert_date(maturity_date)
 
     ff_interpolator = Interpolator(
         "flat_forward",
-        bday.count(settlement_date, df_di["ExpirationDate"]),
-        df_di["SettlementRate"],
+        bday.count(settlement_date, di_expirations),
+        di_rates,
     )
 
-    # Get the corresponding YTM for the NTN-F bond
-    ytm = indicative_rates(reference_date, maturity_date)
+    # Ensure the DI rates and expirations lists are of equal length
+    if len(di_rates) != len(di_expirations):
+        raise ValueError("di_rates and di_expirations must have the same length.")
 
+    # Calculate cash flows and business days between settlement and payment dates
     df = cash_flows(settlement_date, maturity_date).reset_index()
     df["BDays"] = bday.count(settlement_date, df["PaymentDate"])
 
+    # Calculate business years (252 business days per year)
     byears = bday.count(settlement_date, df["PaymentDate"]) / 252
-    di_rates = df["BDays"].apply(ff_interpolator)
+    di_interp = df["BDays"].apply(ff_interpolator)
     bond_price = price(settlement_date, maturity_date, ytm)
     bond_cash_flows = df["CashFlow"]
 
     def price_difference(p):
-        return (bond_cash_flows / (1 + di_rates + p) ** (byears)).sum() - bond_price
+        # Calculate the difference between the bond's price and its disc. cash flows
+        return (bond_cash_flows / (1 + di_interp + p) ** byears).sum() - bond_price
 
     try:
-        # Tentar encontrar o valor de p que zera a diferença entre os preços
-        # Intervalo de busca de -0.01 a 0.01 (100 bps)
-        p_solution = brentq(price_difference, -0.01, 0.01, maxiter=100)
+        if initial_guess:
+            # Search interval is 50 bps above and below the initial guess
+            a = initial_guess - 50 / 10_000  # 50 bps below the initial guess
+            b = initial_guess + 50 / 10_000  # 50 bps above the initial guess
+        else:
+            # Search interval is from -0.01 to 0.01 (i.e., -100 to 100 bps)
+            a = -0.01
+            b = 0.01
+
+        # Find the spread (p) that zeroes the price difference
+        p_solution = brentq(price_difference, a, b, maxiter=100)
+        # Convert the solution to basis points (bps) and round to two decimal places
+        p_solution = round((p_solution * 10_000), 2)
     except (ValueError, RuntimeError):
-        # Se não houver solução, retornar float('nan')
+        # If no solution is found, return NaN
         p_solution = float("nan")
 
-    return p_solution * 10_000
+    return p_solution

{pyield-0.12.0 → pyield-0.12.2}/pyield/di.py

@@ -44,7 +44,7 @@ class DIData:
         adjust_exp_date: bool = False,
     ) -> pd.DataFrame:
         cls._check_for_updates()
-        df = cls._df.copy()
+        df = cls._df[["TradeDate", "ExpirationDate", "SettlementRate"]].copy()
 
         if trade_date:
             trade_date = dc.convert_date(trade_date)
@@ -56,8 +56,6 @@ class DIData:
             expiration_date = bday.offset(expiration_date, 0)
             df.query("ExpirationDate == @expiration_date", inplace=True)
 
-        df = df[["TradeDate", "ExpirationDate", "SettlementRate"]].copy()
-
         if adjust_exp_date:
             df["ExpirationDate"] = (
                 df["ExpirationDate"].dt.to_period("M").dt.to_timestamp()

{pyield-0.12.0 → pyield-0.12.2}/pyproject.toml

@@ -34,7 +34,7 @@ dependencies = [
     "pyarrow",
 ]
 dynamic = []
-version = "0.12.0"
+version = "0.12.2"
 
 [project.license]
 file = "LICENSE"
@@ -80,4 +80,4 @@ select = [
 
 [tool.ruff.format]
 docstring-code-format = true
-docstring-code-line-length = 79
+docstring-code-line-length = 88

pyield-0.12.0/pyield/__about__.py

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