PYield 0.16.2__tar.gz → 0.16.4__tar.gz

{pyield-0.16.2 → pyield-0.16.4}/PKG-INFO

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

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

{pyield-0.16.2 → pyield-0.16.4}/pyield/bonds/bond_tools.py

@@ -40,6 +40,19 @@ def calculate_present_value(
     rates: pd.Series,
     periods: pd.Series,
 ) -> float:
+    # Return 0 if any input is empty
+    if cash_flows.empty or rates.empty or periods.empty:
+        return 0
+
+    # Reset the index to avoid issues with the series alignment
+    cash_flows = cash_flows.reset_index(drop=True)
+    rates = rates.reset_index(drop=True)
+    periods = periods.reset_index(drop=True)
+
+    # Check if data have the same length
+    if len(cash_flows) != len(rates) or len(cash_flows) != len(periods):
+        raise ValueError("All series must have the same length.")
+
     return (cash_flows / (1 + rates) ** periods).sum()
 
 

{pyield-0.16.2 → pyield-0.16.4}/pyield/bonds/lft.py

@@ -2,7 +2,7 @@ import pandas as pd
 
 from .. import bday
 from .. import date_converter as dc
-from ..data import anbima, di
+from ..data import anbima
 from . import bond_tools as bt
 
 
@@ -77,47 +77,26 @@ def quotation(
     return bt.truncate(100 * discount_factor, 4)
 
 
-def premium(lft_rate: float, di_rate: float) -> float:
-    di_factor = (1 + di_rate) ** (1 / 252)
-    lft_factor = (1 + lft_rate) ** (1 / 252) * di_factor
-
-    return (lft_factor - 1) / (di_factor - 1)
-
-
-def historical_premium(
-    reference_date: str | pd.Timestamp,
-    maturity: str | pd.Timestamp,
-) -> float:
+def premium(lft_rate: float, selic_over: float) -> float:
     """
-    Calculate the premium of the LFT bond over the DI Future rate for a given date.
+    Calculate the premium of the LFT bond over the Selic rate (overnight).
+    Obs: The Selic rate (overnight) is not the same as the Selic target rate
 
     Args:
-        reference_date (str | pd.Timestamp): The reference date to fetch the rates.
-        maturity (str | pd.Timestamp): The maturity date of the LFT bond.
+        lft_rate (float): The LFT rate for the bond.
+        selic_over (float): The Selic overnight rate.
 
     Returns:
-        float: The premium of the LFT bond over the DI Future rate for the given date.
-               If the data is not available, returns NaN.
-    """
-    # Convert input dates to a consistent format
-    reference_date = dc.convert_date(reference_date)
-    maturity = dc.convert_date(maturity)
+        float: The premium of the LFT bond over the Selic rate.
 
-    # Retrieve LFT rates for the reference date
-    df_anbima = rates(reference_date)
-    if df_anbima.empty:
-        return float("NaN")
-
-    # Extract the LFT rate for the specified maturity date
-    lft_rates = df_anbima.query("MaturityDate == @maturity")["IndicativeRate"]
-    if lft_rates.empty:
-        return float("NaN")
-    lft_rate = float(lft_rates.iloc[0])
-
-    # Retrieve DI rate for the reference date and maturity
-    di_rate = di.rate(trade_date=reference_date, expiration=maturity)
-    if pd.isnull(di_rate):  # Check if the DI rate is NaN
-        return float("NaN")
-
-    # Calculate and return the premium using the extracted rates
-    return premium(lft_rate, di_rate)
+    Examples:
+        Calculate the premium of a LFT bond with a 0.02 yield rate over the Selic rate:
+        >>> lft_rate = 0.1695 / 100  # 0.1695%
+        >>> selic_over = 10.40 / 100  # 10.40%
+        >>> lft.premium(lft_rate, selic_over)
+        101.71205192837589
+    """
+    adjusted_lft_rate = (lft_rate + 1) * (selic_over + 1) - 1
+    f1 = (adjusted_lft_rate + 1) ** (1 / 252) - 1
+    f2 = (selic_over + 1) ** (1 / 252) - 1
+    return f1 / f2

{pyield-0.16.2 → pyield-0.16.4}/pyield/bonds/ntnb.py

@@ -65,7 +65,7 @@ def rates(reference_date: str | pd.Timestamp) -> pd.DataFrame:
         pd.DataFrame: DataFrame containing the maturity dates and indicative rates
             for the NTN-B bonds.
     """
-    ntnb_rates = anbima.rates(reference_date, "LTN")
+    ntnb_rates = anbima.rates(reference_date, "NTN-B")
     if ntnb_rates.empty:
         return pd.DataFrame()
     return ntnb_rates[["MaturityDate", "IndicativeRate"]]
@@ -121,7 +121,7 @@ def _coupon_dates_map(
     return pd.Series(coupon_dates).reset_index(drop=True)
 
 
-def coupon_dates(
+def payment_dates(
     settlement: str | pd.Timestamp,
     maturity: str | pd.Timestamp,
 ) -> pd.Series:
@@ -186,13 +186,13 @@ def cash_flows(
     maturity = dc.convert_date(maturity)
 
     # Get the coupon dates between the settlement and maturity dates
-    payment_dates = coupon_dates(settlement, maturity)
+    p_dates = payment_dates(settlement, maturity)
 
     # Set the cash flow at maturity to FINAL_PMT and the others to COUPON_PMT
-    cfs = np.where(payment_dates == maturity, FINAL_PMT, COUPON_PMT).tolist()
+    cfs = np.where(p_dates == maturity, FINAL_PMT, COUPON_PMT).tolist()
 
     # Return a dataframe with the payment dates and cash flows
-    return pd.DataFrame(data={"PaymentDate": payment_dates, "CashFlow": cfs})
+    return pd.DataFrame(data={"PaymentDate": p_dates, "CashFlow": cfs})
 
 
 def quotation(
@@ -231,12 +231,12 @@ def quotation(
     maturity = dc.convert_date(maturity)
     _check_maturities(maturity)
 
-    df_cf = cash_flows(settlement, maturity)
-    payment_dates = df_cf["PaymentDate"]
-    cf_values = df_cf["CashFlow"]
+    cf_df = cash_flows(settlement, maturity)
+    cf_dates = cf_df["PaymentDate"]
+    cf_values = cf_df["CashFlow"]
 
     # Calculate the number of business days between settlement and cash flow dates
-    bdays = bday.count(settlement, payment_dates)
+    bdays = bday.count(settlement, cf_dates)
 
     # Calculate the number of periods truncated as per Anbima rules
     num_of_years = bt.truncate(bdays / 252, 14)
@@ -244,10 +244,10 @@ def quotation(
     discount_factor = (1 + rate) ** num_of_years
 
     # Calculate the present value of each cash flow (DCF) rounded as per Anbima rules
-    discounted_cash_flows = (cf_values / discount_factor).round(10)
+    cf_present_value = (cf_values / discount_factor).round(10)
 
     # Return the quotation (the dcf sum) truncated as per Anbima rules
-    return bt.truncate(discounted_cash_flows.sum(), 4)
+    return bt.truncate(cf_present_value.sum(), 4)
 
 
 def price(
@@ -274,32 +274,10 @@ def price(
     return bt.truncate(vna * quotation / 100, 6)
 
 
-def _calculate_coupons_pv(
-    bootstrap_df: pd.DataFrame,
-    settlement: pd.Timestamp,
-    maturity: pd.Timestamp,
-) -> float:
-    # Create a subset DataFrame with only the coupon payments (without last payment)
-    cp_dates_wo_last = coupon_dates(settlement, maturity)[:-1]  # noqa
-    if len(cp_dates_wo_last) == 0:
-        return 0
-
-    df_coupons = bootstrap_df.query("MaturityDate in @cp_dates_wo_last").copy()
-    df_coupons["Coupon"] = COUPON_PMT
-
-    # Calculate the present value of the coupon payments
-    pv = bt.calculate_present_value(
-        cash_flows=df_coupons["Coupon"],
-        rates=df_coupons["SpotRate"],
-        periods=df_coupons["BDays"] / 252,
-    )
-    return pv
-
-
 def spot_rates(
     settlement: str | pd.Timestamp,
-    rates: pd.Series,
     maturities: pd.Series,
+    rates: pd.Series,
 ) -> pd.DataFrame:
     """
     Calculate the spot rates for NTN-B bonds using the bootstrap method.
@@ -312,9 +290,8 @@ def spot_rates(
 
     Args:
         settlement (str | pd.Timestamp): The reference date for settlement.
-        rates (pd.Series): Series of yield to maturity rates indexed by the
-            maturity dates of the bonds.
         maturities (pd.Series): Series of maturity dates for the bonds.
+        rates (pd.Series): Series of yield to maturity rates.
 
     Returns:
         pd.DataFrame: DataFrame containing the maturity dates and corresponding real
@@ -329,51 +306,55 @@ def spot_rates(
     """
     # Process and validate the input data
     settlement = dc.convert_date(settlement)
-    maturities = pd.to_datetime(maturities, errors="coerce", dayfirst=True)
+    maturities = pd.to_datetime(maturities, errors="raise", dayfirst=True)
     _check_maturities(maturities)
 
     # Create the interpolator object
-    ytm_rate_interpolator = it.Interpolator(
+    ff_interpolator = it.Interpolator(
         method="flat_forward",
         known_bdays=bday.count(settlement, maturities),
         known_rates=rates,
     )
 
-    last_ntnb = maturities.max()
-
     # Generate coupon dates up to the longest maturity date
-    all_coupon_dates = _coupon_dates_map(start=settlement, end=last_ntnb)
+    all_coupon_dates = _coupon_dates_map(start=settlement, end=maturities.max())
 
     # Create a DataFrame with all coupon dates and the corresponding YTM
-    df_spot = pd.DataFrame(data=all_coupon_dates, columns=["MaturityDate"])
-    df_spot["BDays"] = bday.count(settlement, df_spot["MaturityDate"])
-    df_spot["YTM"] = df_spot["BDays"].apply(ytm_rate_interpolator)
+    df = pd.DataFrame(data=all_coupon_dates, columns=["MaturityDate"])
+    df["BDays"] = bday.count(settlement, df["MaturityDate"])
+    df["BYears"] = df["BDays"] / 252
+    df["YTM"] = df["BDays"].apply(ff_interpolator)
+    df["Coupon"] = COUPON_PMT
+    df["SpotRate"] = pd.NA
 
     # The Bootstrap loop to calculate spot rates
-    for index in df_spot.index:
-        # Get the row values using the index
-        maturity = df_spot.at[index, "MaturityDate"]
-        bdays = df_spot.at[index, "BDays"]
-        ytm = df_spot.at[index, "YTM"]
-
-        # Get the coupon dates for the bond without the last one (principal + coupon)
-        cp_dates = coupon_dates(settlement, maturity)
+    for index, row in df.iterrows():
+        # Get the cash flow dates for the bond
+        cf_dates = payment_dates(settlement, row["MaturityDate"])
 
         # If there is only one coupon date and this date is the first maturity date
         # of an existing bond, the ytm rate is also a spot rate.
-        if len(cp_dates) == 1 and cp_dates[0] == rates[0]:
-            df_spot.at[index, "SpotRate"] = ytm
+        if len(cf_dates) == 1 and cf_dates[0] == maturities[0]:
+            df.at[index, "SpotRate"] = row["YTM"]
             continue
 
-        # Calculate the real spot rate for the bond
-        coupons_pv = _calculate_coupons_pv(df_spot, settlement, maturity)
-        bond_price = quotation(settlement, maturity, ytm)
-        spot_rate = (FINAL_PMT / (bond_price - coupons_pv)) ** (252 / bdays) - 1
-        df_spot.at[index, "SpotRate"] = spot_rate
-
-    df_spot.drop(columns=["BDays"], inplace=True)
+        # Calculate the present value of the cash flows without last payment
+        cf_dates = cf_dates[:-1]
+        cf_df = df.query("MaturityDate in @cf_dates").reset_index(drop=True)
+        cf_present_value = bt.calculate_present_value(
+            cash_flows=cf_df["Coupon"],
+            rates=cf_df["SpotRate"],
+            periods=cf_df["BYears"],
+        )
+
+        # Calculate the Spot Rate for the bond
+        bond_price = quotation(settlement, row["MaturityDate"], row["YTM"])
+        price_factor = FINAL_PMT / (bond_price - cf_present_value)
+        df.at[index, "SpotRate"] = price_factor ** (1 / row["BYears"]) - 1
+
+    df.drop(columns=["BDays", "BYears", "Coupon"], inplace=True)
     # Return the result without the intermediate coupon dates (virtual bonds)
-    return df_spot.query("MaturityDate in @maturities").reset_index(drop=True)
+    return df.query("MaturityDate in @maturities").reset_index(drop=True)
 
 
 def _get_nir_df(reference_date: pd.Timestamp) -> pd.DataFrame:

{pyield-0.16.2 → pyield-0.16.4}/pyield/bonds/ntnf.py

@@ -180,9 +180,9 @@ def price(
         >>> price("05-07-2024", "01-01-2035", 0.11921)
         895.359254
     """
-    df_cf = cash_flows(settlement, maturity)
-    cf_values = df_cf["CashFlow"]
-    bdays = bday.count(settlement, df_cf["PaymentDate"])
+    cf_df = cash_flows(settlement, maturity)
+    cf_values = cf_df["CashFlow"]
+    bdays = bday.count(settlement, cf_df["PaymentDate"])
     byears = bt.truncate(bdays / 252, 14)
     discount_factors = (1 + rate) ** byears
     # Calculate the present value of each cash flow (DCF) rounded as per Anbima rules
@@ -191,31 +191,12 @@ def price(
     return bt.truncate(dcf.sum(), 6)
 
 
-def _calculate_coupons_pv(
-    bootstrap_df: pd.DataFrame,
-    settlement: pd.Timestamp,
-    maturity: pd.Timestamp,
-) -> float:
-    # Create a subset DataFrame with only the coupon payments (without last payment)
-    cp_dates_wo_last = coupon_dates(settlement, maturity)[:-1]  # noqa
-    df_coupons = bootstrap_df.query("MaturityDate in @cp_dates_wo_last").copy()
-    df_coupons["Coupon"] = COUPON_PMT
-
-    # Calculate the present value of the coupon payments
-    pv = bt.calculate_present_value(
-        cash_flows=df_coupons["Coupon"],
-        rates=df_coupons["SpotRate"],
-        periods=df_coupons["BDays"] / 252,
-    )
-    return pv
-
-
 def spot_rates(
     settlement: str | pd.Timestamp,
-    ltn_rates: pd.Series,
     ltn_maturities: pd.Series,
-    ntnf_rates: pd.Series,
+    ltn_rates: pd.Series,
     ntnf_maturities: pd.Series,
+    ntnf_rates: pd.Series,
 ) -> pd.DataFrame:
     """
     Calculate the spot rates for NTN-F bonds using the bootstrap method.
@@ -252,36 +233,38 @@ def spot_rates(
         known_rates=ntnf_rates,
     )
 
-    # Determine the last maturity dates for LTN and NTN-F rates
-    last_ltn = ltn_maturities.max()
-    last_ntnf = ntnf_maturities.max()
-
     # Generate all coupon dates up to the last NTN-F maturity date
-    all_coupon_dates = coupon_dates(settlement, last_ntnf)
+    all_coupon_dates = coupon_dates(settlement, ntnf_maturities.max())
 
     # Create a DataFrame with all coupon dates and the corresponding YTM
-    df_spot = pd.DataFrame(data=all_coupon_dates, columns=["MaturityDate"])
-    df_spot["BDays"] = bday.count(start=settlement, end=df_spot["MaturityDate"])
-    df_spot["YTM"] = df_spot["BDays"].apply(ntnf_rate_interpolator)
+    df = pd.DataFrame(data=all_coupon_dates, columns=["MaturityDate"])
+    df["BDays"] = bday.count(start=settlement, end=df["MaturityDate"])
+    df["BYears"] = df["BDays"] / 252
+    df["Coupon"] = COUPON_PMT
+    df["YTM"] = df["BDays"].apply(ntnf_rate_interpolator)
 
     # The Bootstrap loop to calculate spot rates
-    for index in df_spot.index:
-        maturity = df_spot.at[index, "MaturityDate"]
-        bdays = df_spot.at[index, "BDays"]
-
-        if maturity <= last_ltn:
+    for index, row in df.iterrows():
+        if row["MaturityDate"] <= ltn_maturities.max():
             # Use LTN rates for maturities before the last LTN maturity date
-            df_spot.at[index, "SpotRate"] = ltn_rate_interpolator(bdays)
+            df.at[index, "SpotRate"] = ltn_rate_interpolator(row["BDays"])
             continue
 
-        # Calculate the spot rate for the bond
-        coupons_pv = _calculate_coupons_pv(df_spot, settlement, maturity)
-        ytm = df_spot.at[index, "YTM"]
-        bond_price = price(settlement, maturity, ytm)
-        spot_rate = (FINAL_PMT / (bond_price - coupons_pv)) ** (252 / bdays) - 1
-        df_spot.at[index, "SpotRate"] = spot_rate
+        # Calculate the present value of the coupon payments
+        cf_dates = coupon_dates(settlement, row["MaturityDate"])[:-1]  # noqa
+        cf_df = df.query("MaturityDate in @cf_dates").reset_index(drop=True)
+        cf_present_value = bt.calculate_present_value(
+            cash_flows=cf_df["Coupon"],
+            rates=cf_df["SpotRate"],
+            periods=cf_df["BDays"] / 252,
+        )
+
+        bond_price = price(settlement, row["MaturityDate"], row["YTM"])
+        price_factor = FINAL_PMT / (bond_price - cf_present_value)
+        df.at[index, "SpotRate"] = price_factor ** (1 / row["BYears"]) - 1
 
-    return df_spot
+    # Remove temporary columns and return the spot rates DataFrame
+    return df[["MaturityDate", "BDays", "YTM", "SpotRate"]].copy()
 
 
 def di_spreads(reference_date: str | pd.Timestamp) -> pd.DataFrame:
@@ -328,7 +311,6 @@ def _bisection_method(func, a, b, tol=1e-8, maxiter=100):
 def _solve_spread(
     price_difference_func: Callable,
     initial_guess: float | None = None,
-    range_width_bps: float = 50,
 ) -> float:
     """
     Solve for the spread that zeroes the price difference using a bisection method.
@@ -337,8 +319,6 @@ def _solve_spread(
         price_difference_func (callable): The function that computes the difference
             between the bond's market price and its discounted cash flows.
         initial_guess (float, optional): An initial guess for the spread.
-        range_width_bps (float, optional): The width of the range around the initial
-        guess in bps. Defaults to 50 bps.
 
     Returns:
         float: The solution for the spread in bps or NaN if no solution is found.
@@ -346,9 +326,9 @@ def _solve_spread(
     try:
         if initial_guess is not None:
             # range_width_bps below the initial guess
-            a = initial_guess - range_width_bps / 10_000
+            a = initial_guess - 0.005  # 50 bps
             # range_width_bps above the initial guess
-            b = initial_guess + range_width_bps / 10_000
+            b = initial_guess + 0.005  # 50 bps
         else:
             a = -0.01  # Initial guess of -100 bps
             b = 0.01  # Initial guess of 100 bps
@@ -366,8 +346,8 @@ def di_net_spread(  # noqa
     settlement: str | pd.Timestamp,
     maturity: str | pd.Timestamp,
     ytm: float,
-    di_rates: pd.Series,
     di_expirations: pd.Series,
+    di_rates: pd.Series,
     initial_guess: float | None = None,
 ) -> float:
     """
@@ -388,7 +368,7 @@ def di_net_spread(  # noqa
         di_rates (pd.Series): A Series of DI rates.
         di_expirations (pd.Series): A list or Series of DI expiration dates.
         initial_guess (float, optional): An initial guess for the spread. Defaults to
-            None.
+            None. A good initial guess is the DI gross spread for the bond.
 
     Returns:
         float: The net DI spread in basis points.
@@ -422,7 +402,7 @@ def di_net_spread(  # noqa
         # Difference between the bond's price and its discounted cash flows
         return (bond_cash_flows / (1 + di_interp + p) ** byears).sum() - bond_price
 
-    # Solve for the spread that zeroes the price difference using the Brent method
+    # Solve for the spread that zeroes the price difference using the bisection method
     p_solution = _solve_spread(price_difference, initial_guess)
     # Convert the solution to basis points (bps) and round to two decimal places
     return round((p_solution * 10_000), 2)
@@ -430,10 +410,10 @@ def di_net_spread(  # noqa
 
 def premium(
     settlement: str | pd.Timestamp,
-    ntnf_rate: float,
     ntnf_maturity: str | pd.Timestamp,
-    di_rates: pd.Series,
+    ntnf_rate: float,
     di_expirations: pd.Series,
+    di_rates: pd.Series,
 ) -> float:
     ntnf_maturity = dc.convert_date(ntnf_maturity)
     settlement = dc.convert_date(settlement)

{pyield-0.16.2 → pyield-0.16.4}/pyield/data/indicators.py

@@ -7,15 +7,17 @@ from .. import date_converter as dc
 
 
 def indicator(
-    indicator_type: Literal["IPCA_MR", "SELIC_TARGET", "DI", "VNA_LFT"],
+    indicator_type: Literal["IPCA_MR", "SELIC_TARGET", "SELIC_OVER", "DI", "VNA_LFT"],
     reference_date: str | pd.Timestamp,
-) -> float | None:
+) -> float:
     reference_date = dc.convert_date(reference_date)
     ind_type = str(indicator_type).upper()
     if ind_type == "IPCA_MR":
         return ipca_monthly_rate(reference_date)
     elif ind_type == "SELIC_TARGET":
         return selic_target(reference_date)
+    elif ind_type == "SELIC_OVER":
+        return selic_over(reference_date)
     elif ind_type == "DI":
         return di(reference_date)
     elif ind_type == "VNA_LFT":
@@ -24,7 +26,7 @@ def indicator(
         raise ValueError(f"Invalid indicator type: {ind_type}")
 
 
-def ipca_monthly_rate(reference_date: pd.Timestamp) -> float | None:
+def ipca_monthly_rate(reference_date: pd.Timestamp) -> float:
     """
     Fetches the IPCA (Índice Nacional de Preços ao Consumidor Amplo) monthly rate
     from the IBGE (Instituto Brasileiro de Geografia e Estatística) for a given
@@ -35,7 +37,7 @@ def ipca_monthly_rate(reference_date: pd.Timestamp) -> float | None:
             is fetched. If a string is passed, it should be in 'DD-MM-YYYY' format.
 
     Returns:
-        float | None: The IPCA monthly rate for the specified date as a float.
+        float: The IPCA monthly rate for the specified date as a float.
         Returns None if data is not found or in case of an error.
 
     Notes:
@@ -65,15 +67,14 @@ def ipca_monthly_rate(reference_date: pd.Timestamp) -> float | None:
     # Parse the JSON response
     data = response.json()
 
+    if not data:
+        return float("nan")
     # Extract and return the IPCA monthly growth rate if data is available
-    if data:
-        ipca_str = data[0]["resultados"][0]["series"][0]["serie"][ipca_date]
-        return round(float(ipca_str) / 100, 4)
-    else:
-        return None
+    ipca_str = data[0]["resultados"][0]["series"][0]["serie"][ipca_date]
+    return round(float(ipca_str) / 100, 4)
 
 
-def selic_target(reference_date: pd.Timestamp) -> float | None:
+def selic_target(reference_date: pd.Timestamp) -> float:
     """
     Examples:
         >>> selic_taget("31-05-2024")
@@ -85,14 +86,31 @@ def selic_target(reference_date: pd.Timestamp) -> float | None:
     response = requests.get(api_url, timeout=10)
     response.raise_for_status()
 
-    if selic_date in response.text:
-        data = response.json()
-        return round(float(data[0]["valor"]) / 100, 4)
-    else:
-        return None
+    if selic_date not in response.text:
+        return float("nan")
+    data = response.json()
+    return round(float(data[0]["valor"]) / 100, 4)
+
+
+def selic_over(reference_date: pd.Timestamp) -> float:
+    """
+    Examples:
+        >>> selic_over("26-08-2024")
+        0.1040  # Indicates a SELIC rate of 10.40% p.a.
+    """
+    # https://api.bcb.gov.br/dados/serie/bcdata.sgs.1178/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
+    formatted_date = reference_date.strftime("%d/%m/%Y")
+    api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.1178/dados?formato=json&dataInicial={formatted_date}&dataFinal={formatted_date}"
+    response = requests.get(api_url, timeout=10)
+    response.raise_for_status()
 
+    if formatted_date not in response.text:
+        return float("nan")
+    data = response.json()
+    return round(float(data[0]["valor"]) / 100, 4)
 
-def di(reference_date: pd.Timestamp) -> float | None:
+
+def di(reference_date: pd.Timestamp) -> float:
     """
     Examples:
         >>> di("31-05-2024")
@@ -104,14 +122,13 @@ def di(reference_date: pd.Timestamp) -> float | None:
     response = requests.get(api_url, timeout=10)
     response.raise_for_status()
 
-    if di_date in response.text:
-        data = response.json()
-        return round(float(data[0]["valor"]) / 100, 8)
-    else:
-        return None
+    if di_date not in response.text:
+        return float("nan")
+    data = response.json()
+    return round(float(data[0]["valor"]) / 100, 8)
 
 
-def vna_lft(reference_date: pd.Timestamp) -> float | None:
+def vna_lft(reference_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"

{pyield-0.16.2 → pyield-0.16.4}/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
     "types-requests",
 ]
 dynamic = []
-version = "0.16.2"
+version = "0.16.4"
 
 [project.license]
 file = "LICENSE"

pyield-0.16.2/pyield/__about__.py

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