PYield 0.31.0__tar.gz → 0.31.2__tar.gz

{pyield-0.31.0 → pyield-0.31.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.31.0
+Version: 0.31.2
 Summary: A Python library for analysis of fixed income instruments in Brazil
 Project-URL: Source, https://github.com/crdcj/PYield
 Author-email: Carlos Carvalho <cr.cj@outlook.com>
@@ -49,8 +49,6 @@ PYield is a Python library designed for the analysis of Brazilian fixed income i
 
 Documentation: [https://crdcj.github.io/PYield/](https://crdcj.github.io/PYield/)
 
-Source Code: [https://github.com/crdcj/PYield](https://github.com/crdcj/PYield)
-
 ## Key Features
 
 - **Data Collection**: Automated fetching of data from ANBIMA and B3.
@@ -103,38 +101,39 @@ date = pd.to_datetime("05-31-2024", format="%m-%d-%Y")
 ```python
 >>> from pyield import ntnb, ntnf, ltn
 
+# Get ANBIMA data for a given date
+>>> ltn.data("23-08-2024")
+    ReferenceDate BondType MaturityDate  IndicativeRate       Price
+0     2024-08-23      LTN   2024-10-01        0.104416  989.415342
+1     2024-08-23      LTN   2025-01-01        0.107171  964.293046
+2     2024-08-23      LTN   2025-04-01        0.110866  938.943013
+3     2024-08-23      LTN   2025-07-01        0.113032  913.849158
+4     2024-08-23      LTN   2025-10-01        0.114374  887.394285
+5     2024-08-23      LTN   2026-01-01        0.114654  863.026594
+6     2024-08-23      LTN   2026-04-01        0.114997  840.232741
+7     2024-08-23      LTN   2026-07-01        0.115265  818.020491
+8     2024-08-23      LTN   2026-10-01        0.115357  795.185488
+9     2024-08-23      LTN   2027-07-01        0.115335  733.981131
+10    2024-08-23      LTN   2028-01-01        0.115694  693.647778
+11    2024-08-23      LTN   2028-07-01        0.116417    655.6398
+12    2024-08-23      LTN   2030-01-01        0.117436  554.331151
+
 # Calculate the quotation of a NTN-B bond as per ANBIMA's rules
 >>> ntnb.quotation("31-05-2024", "15-05-2035", 0.061490)
 99.3651
 >>> ntnb.quotation("31-05-2024", "15-08-2060", 0.061878)
 99.5341
 
-# Calculate the DI Spread of NTN-F bonds in a given date
->>> ntnf.di_spreads("17-07-2024")
-2025-01-01   -2.31
-2027-01-01   -1.88
-2029-01-01   -3.26
-2031-01-01    3.61
-2033-01-01   -3.12
-2035-01-01   -1.00
-Name: DISpread, dtype: Float64
-
-# Get ANBIMA's indicative rates for LTN bonds
->>> ltn.anbima_rates("17-07-2024")
-2024-10-01    0.104236
-2025-01-01    0.105400
-2025-04-01    0.107454
-2025-07-01    0.108924
-2025-10-01    0.110751
-2026-01-01    0.111753
-2026-04-01    0.112980
-2026-07-01    0.113870
-2026-10-01    0.114592
-2027-07-01    0.116090
-2028-01-01    0.117160
-2028-07-01    0.118335
-2030-01-01    0.120090
-Name: IndicativeRate, dtype: Float64
+# Calculate the DI Spread of NTN-F and LTN bonds in a given date
+>>> ntnf.di_spreads("23-08-2024")
+    MaturityDate  DISpread
+0   2025-01-01     -5.38
+1   2027-01-01      4.39
+2   2029-01-01      7.37
+3   2031-01-01     12.58
+4   2033-01-01      7.67
+5   2035-01-01     12.76
+
 ```
 
 ### Business Days Tools (Brazilian holidays are automatically considered)
@@ -162,22 +161,11 @@ Timestamp('2023-12-29 00:00:00')
 0   2023-12-29
 1   2024-01-02
 2   2024-01-03
-dtype: datetime64[ns]
 ```
 
 ### Futures Data
 ```python
 >>> import pyield as yd
-# Fetch current DI Futures data from B3 (15 minutes delay)
->>> yd.futures(contract_code="DI1")
-LastUpdatee      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate LastRate
-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
-                ...          ...            ...        ... ...     ...         ...         ...      ...
-2024-04-21 13:37:39       DI1F37     2037-01-02       3183 ...    <NA>        <NA>     0.11600     <NA>
-2024-04-21 13:37:39       DI1F38     2038-01-04       3432 ...    <NA>        <NA>     0.11600     <NA>
-2024-04-21 13:37:39       DI1F39     2039-01-03       3683 ...    <NA>        <NA>        <NA>     <NA>
 
 # Fetch historical DI Futures data from B3
 >>> yd.futures(contract_code="DI1", date='08-03-2024')
@@ -189,20 +177,35 @@ TradeDate  TickerSymbol ExpirationDate BDaysToExp ... LastRate LastAskRate LastB
 2024-03-08       DI1F37     2037-01-02       3213 ...     <NA>        <NA>        <NA>         10.859
 2024-03-08       DI1F38     2038-01-04       3462 ...     <NA>        <NA>        <NA>         10.859
 2024-03-08       DI1F39     2039-01-03       3713 ...     <NA>        <NA>        <NA>         10.85
+
+# Fetch current DI Futures data from B3 (15 minutes delay)
+>>> yd.futures(contract_code="DI1", date="21-03-2024")  # when the date used is the current date and market is open
+LastUpdatee      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate LastRate
+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
+                ...          ...            ...        ... ...     ...         ...         ...      ...
+2024-04-21 13:37:39       DI1F37     2037-01-02       3183 ...    <NA>        <NA>     0.11600     <NA>
+2024-04-21 13:37:39       DI1F38     2038-01-04       3432 ...    <NA>        <NA>     0.11600     <NA>
+2024-04-21 13:37:39       DI1F39     2039-01-03       3683 ...    <NA>        <NA>        <NA>     <NA>
 ```
 
 ### Indicators Data
 ```python
 >>> from pyield import bc
-# Fetch the SELIC target rate from the Central Bank of Brazil
->>> bc.selic_over("26-01-2025")  # No data on 26-01-2025 (sunday)
+
+# Fetch the SELIC target rates from the Central Bank of Brazil
+>>> bc.selic_over_series("26-01-2025", "30-01-2025")  # No data on 26-01-2025 (sunday)
         Date   Value
 0 2025-01-27  0.1215
 1 2025-01-28  0.1215
 2 2025-01-29  0.1215
 3 2025-01-30  0.1315
-4 2025-01-31  0.1315
-...
+
+# Fetch the SELIC target rate for a specific date
+>>> bc.selic_over("27-01-2025")
+        Date   Value
+0.1215  # 12.15%
 ```
 
 ### Projections Data

{pyield-0.31.0 → pyield-0.31.2}/README.md

@@ -8,8 +8,6 @@ PYield is a Python library designed for the analysis of Brazilian fixed income i
 
 Documentation: [https://crdcj.github.io/PYield/](https://crdcj.github.io/PYield/)
 
-Source Code: [https://github.com/crdcj/PYield](https://github.com/crdcj/PYield)
-
 ## Key Features
 
 - **Data Collection**: Automated fetching of data from ANBIMA and B3.
@@ -62,38 +60,39 @@ date = pd.to_datetime("05-31-2024", format="%m-%d-%Y")
 ```python
 >>> from pyield import ntnb, ntnf, ltn
 
+# Get ANBIMA data for a given date
+>>> ltn.data("23-08-2024")
+    ReferenceDate BondType MaturityDate  IndicativeRate       Price
+0     2024-08-23      LTN   2024-10-01        0.104416  989.415342
+1     2024-08-23      LTN   2025-01-01        0.107171  964.293046
+2     2024-08-23      LTN   2025-04-01        0.110866  938.943013
+3     2024-08-23      LTN   2025-07-01        0.113032  913.849158
+4     2024-08-23      LTN   2025-10-01        0.114374  887.394285
+5     2024-08-23      LTN   2026-01-01        0.114654  863.026594
+6     2024-08-23      LTN   2026-04-01        0.114997  840.232741
+7     2024-08-23      LTN   2026-07-01        0.115265  818.020491
+8     2024-08-23      LTN   2026-10-01        0.115357  795.185488
+9     2024-08-23      LTN   2027-07-01        0.115335  733.981131
+10    2024-08-23      LTN   2028-01-01        0.115694  693.647778
+11    2024-08-23      LTN   2028-07-01        0.116417    655.6398
+12    2024-08-23      LTN   2030-01-01        0.117436  554.331151
+
 # Calculate the quotation of a NTN-B bond as per ANBIMA's rules
 >>> ntnb.quotation("31-05-2024", "15-05-2035", 0.061490)
 99.3651
 >>> ntnb.quotation("31-05-2024", "15-08-2060", 0.061878)
 99.5341
 
-# Calculate the DI Spread of NTN-F bonds in a given date
->>> ntnf.di_spreads("17-07-2024")
-2025-01-01   -2.31
-2027-01-01   -1.88
-2029-01-01   -3.26
-2031-01-01    3.61
-2033-01-01   -3.12
-2035-01-01   -1.00
-Name: DISpread, dtype: Float64
-
-# Get ANBIMA's indicative rates for LTN bonds
->>> ltn.anbima_rates("17-07-2024")
-2024-10-01    0.104236
-2025-01-01    0.105400
-2025-04-01    0.107454
-2025-07-01    0.108924
-2025-10-01    0.110751
-2026-01-01    0.111753
-2026-04-01    0.112980
-2026-07-01    0.113870
-2026-10-01    0.114592
-2027-07-01    0.116090
-2028-01-01    0.117160
-2028-07-01    0.118335
-2030-01-01    0.120090
-Name: IndicativeRate, dtype: Float64
+# Calculate the DI Spread of NTN-F and LTN bonds in a given date
+>>> ntnf.di_spreads("23-08-2024")
+    MaturityDate  DISpread
+0   2025-01-01     -5.38
+1   2027-01-01      4.39
+2   2029-01-01      7.37
+3   2031-01-01     12.58
+4   2033-01-01      7.67
+5   2035-01-01     12.76
+
 ```
 
 ### Business Days Tools (Brazilian holidays are automatically considered)
@@ -121,22 +120,11 @@ Timestamp('2023-12-29 00:00:00')
 0   2023-12-29
 1   2024-01-02
 2   2024-01-03
-dtype: datetime64[ns]
 ```
 
 ### Futures Data
 ```python
 >>> import pyield as yd
-# Fetch current DI Futures data from B3 (15 minutes delay)
->>> yd.futures(contract_code="DI1")
-LastUpdatee      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate LastRate
-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
-                ...          ...            ...        ... ...     ...         ...         ...      ...
-2024-04-21 13:37:39       DI1F37     2037-01-02       3183 ...    <NA>        <NA>     0.11600     <NA>
-2024-04-21 13:37:39       DI1F38     2038-01-04       3432 ...    <NA>        <NA>     0.11600     <NA>
-2024-04-21 13:37:39       DI1F39     2039-01-03       3683 ...    <NA>        <NA>        <NA>     <NA>
 
 # Fetch historical DI Futures data from B3
 >>> yd.futures(contract_code="DI1", date='08-03-2024')
@@ -148,20 +136,35 @@ TradeDate  TickerSymbol ExpirationDate BDaysToExp ... LastRate LastAskRate LastB
 2024-03-08       DI1F37     2037-01-02       3213 ...     <NA>        <NA>        <NA>         10.859
 2024-03-08       DI1F38     2038-01-04       3462 ...     <NA>        <NA>        <NA>         10.859
 2024-03-08       DI1F39     2039-01-03       3713 ...     <NA>        <NA>        <NA>         10.85
+
+# Fetch current DI Futures data from B3 (15 minutes delay)
+>>> yd.futures(contract_code="DI1", date="21-03-2024")  # when the date used is the current date and market is open
+LastUpdatee      TickerSymbol ExpirationDate BDaysToExp ... MaxRate LastAskRate LastBidRate LastRate
+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
+                ...          ...            ...        ... ...     ...         ...         ...      ...
+2024-04-21 13:37:39       DI1F37     2037-01-02       3183 ...    <NA>        <NA>     0.11600     <NA>
+2024-04-21 13:37:39       DI1F38     2038-01-04       3432 ...    <NA>        <NA>     0.11600     <NA>
+2024-04-21 13:37:39       DI1F39     2039-01-03       3683 ...    <NA>        <NA>        <NA>     <NA>
 ```
 
 ### Indicators Data
 ```python
 >>> from pyield import bc
-# Fetch the SELIC target rate from the Central Bank of Brazil
->>> bc.selic_over("26-01-2025")  # No data on 26-01-2025 (sunday)
+
+# Fetch the SELIC target rates from the Central Bank of Brazil
+>>> bc.selic_over_series("26-01-2025", "30-01-2025")  # No data on 26-01-2025 (sunday)
         Date   Value
 0 2025-01-27  0.1215
 1 2025-01-28  0.1215
 2 2025-01-29  0.1215
 3 2025-01-30  0.1315
-4 2025-01-31  0.1315
-...
+
+# Fetch the SELIC target rate for a specific date
+>>> bc.selic_over("27-01-2025")
+        Date   Value
+0.1215  # 12.15%
 ```
 
 ### Projections Data

pyield-0.31.2/pyield/__about__.py

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

{pyield-0.31.0 → pyield-0.31.2}/pyield/__init__.py

@@ -6,7 +6,7 @@ from pyield.b3 import futures
 from pyield.b3.di import DIFutures
 from pyield.forwards import forward_rates
 from pyield.interpolator import Interpolator
-from pyield.tpf import lft, ltn, ntnb, ntnf
+from pyield.tpf import lft, ltn, ntnb, ntnc, ntnf
 
 __all__ = [
     "__version__",
@@ -20,6 +20,7 @@ __all__ = [
     "lft",
     "ltn",
     "ntnb",
+    "ntnc",
     "ntnf",
     "bc",
     "b3",

{pyield-0.31.0 → pyield-0.31.2}/pyield/anbima/__init__.py

@@ -1,4 +1,4 @@
-from pyield.anbima.ettj import last_ettj
+from pyield.anbima.ettj import intraday_ettj, last_ettj
 from pyield.anbima.ima import last_ima
 from pyield.anbima.imaq import imaq
 from pyield.anbima.ipca import ipca_projection
@@ -12,4 +12,5 @@ __all__ = [
     "tpf_data",
     "tpf_fixed_rate_maturities",
     "last_ettj",
+    "intraday_ettj",
 ]

{pyield-0.31.0 → pyield-0.31.2}/pyield/anbima/ettj.py

@@ -4,11 +4,13 @@ from io import StringIO
 import pandas as pd
 import requests
 
-from pyield.forwards import forward_rates
 from pyield.retry import default_retry
 
 logger = logging.getLogger(__name__)
 LAST_ETTJ_URL = "https://www.anbima.com.br/informacoes/est-termo/CZ-down.asp"
+INTRADAY_ETTJ_URL = (
+    "https://www.anbima.com.br/informacoes/curvas-intradiarias/cIntra-down.asp"
+)
 
 # Anbima ETTJ data has 4 decimal places in percentage values
 # We will round to 6 decimal places to avoid floating point errors
@@ -76,31 +78,12 @@ def _process_df(df: pd.DataFrame) -> pd.DataFrame:
     df["nominal_rate"] = (df["nominal_rate"] / 100).round(ROUND_DIGITS)
     df["implied_inflation"] = (df["implied_inflation"] / 100).round(ROUND_DIGITS)
 
-    df["real_rate_fwd"] = forward_rates(
-        business_days=df["vertex"],
-        zero_rates=df["real_rate"],
-        groupby_dates=df["date"],
-    )
-    df["nominal_rate_fwd"] = forward_rates(
-        business_days=df["vertex"],
-        zero_rates=df["nominal_rate"],
-        groupby_dates=df["date"],
-    )
-    df["implied_inflation_fwd"] = forward_rates(
-        business_days=df["vertex"],
-        zero_rates=df["implied_inflation"],
-        groupby_dates=df["date"],
-    )
-
     column_order = [
         "date",
         "vertex",
         "nominal_rate",
         "real_rate",
         "implied_inflation",
-        "nominal_rate_fwd",
-        "real_rate_fwd",
-        "implied_inflation_fwd",
     ]
     df = df[column_order].copy()
 
@@ -113,8 +96,7 @@ def last_ettj() -> pd.DataFrame:
 
     This function fetches the most recent yield curve data published by ANBIMA,
     containing real rates (IPCA-indexed), nominal rates, and implied inflation
-    at various vertices (time points). Both spot rates and forward rates are
-    calculated and included in the returned DataFrame.
+    at various vertices (time points).
 
     Returns:
         pd.DataFrame: A DataFrame containing the latest ETTJ data.
@@ -125,9 +107,6 @@ def last_ettj() -> pd.DataFrame:
         - nominal_rate: Zero-coupon nominal interest rate
         - real_rate: Zero-coupon real interest rate (IPCA-indexed)
         - implied_inflation: Implied inflation rate (break-even inflation)
-        - nominal_rate_fwd: Forward nominal interest rate
-        - real_rate_fwd: Forward real interest rate
-        - implied_inflation_fwd: Forward implied inflation rate
 
     Note:
         All rates are expressed in decimal format (e.g., 0.12 for 12%).
@@ -135,3 +114,57 @@ def last_ettj() -> pd.DataFrame:
     text = _get_last_content()
     df = _convert_text_to_df(text)
     return _process_df(df)
+
+
+def intraday_ettj() -> pd.DataFrame:
+    """
+    Retrieves and processes the intraday Brazilian yield curve data from ANBIMA.
+
+    This function fetches the most recent intraday yield curve data published by ANBIMA,
+    containing real rates (IPCA-indexed), nominal rates, and implied inflation
+    at various vertices (time points). The curve is published at around 12:30 PM BRT.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the intraday ETTJ data.
+
+    DataFrame columns:
+        - date: Reference date of the yield curve
+        - vertex: Time point in business days
+        - nominal_rate: Zero-coupon nominal interest rate
+        - real_rate: Zero-coupon real interest rate (IPCA-indexed)
+        - implied_inflation: Implied inflation rate (break-even inflation)
+
+    Note:
+        All rates are expressed in decimal format (e.g., 0.12 for 12%).
+    """
+    text = requests.get(INTRADAY_ETTJ_URL).text
+    text_parts = text.split("ETTJ IPCA (%a.a./252)")
+
+    nominal_text = text_parts[0]
+    lines = nominal_text.splitlines()
+    date_str = lines[1]
+    date = pd.to_datetime(date_str, format="%d/%m/%Y")
+    df_text = "\n".join(lines[2:])
+    df_nominal = pd.read_csv(StringIO(df_text), sep=";", decimal=",", thousands=".")
+    df_nominal = df_nominal.drop(columns=["Fechamento D -1"])
+    df_nominal = df_nominal.rename(columns={"D0": "nominal_rate"})
+
+    real_text = text_parts[1]
+    lines = real_text.splitlines()
+    df_text = "\n".join(lines[2:])
+    df_real = pd.read_csv(StringIO(df_text), sep=";", decimal=",", thousands=".")
+    df_real = df_real.drop(columns=["Fechamento D -1"])
+    df_real = df_real.rename(columns={"D0": "real_rate"})
+
+    df = pd.merge(df_nominal, df_real, on="Vertices", how="right")
+    df = df.rename(columns={"Vertices": "vertex"})
+
+    # Divide float columns by 100 and round to 6 decimal places
+    df["real_rate"] = (df["real_rate"] / 100).round(ROUND_DIGITS)
+    df["nominal_rate"] = (df["nominal_rate"] / 100).round(ROUND_DIGITS)
+    df["implied_inflation"] = (df["nominal_rate"] + 1) / (df["real_rate"] + 1) - 1
+    df["implied_inflation"] = df["implied_inflation"].round(ROUND_DIGITS)
+
+    df["date"] = date
+    column_order = ["date", "vertex", "nominal_rate", "real_rate", "implied_inflation"]
+    return df[column_order].copy()

{pyield-0.31.0 → pyield-0.31.2}/pyield/anbima/tpf.py

@@ -81,7 +81,8 @@ def _process_raw_df(df_raw: pd.DataFrame) -> pd.DataFrame:
 def tpf_web_data(
     date: DateScalar, bond_type: str | BOND_TYPES | None = None
 ) -> pd.DataFrame:
-    """Fetch and process TPF secondary market data from ANBIMA website.
+    """Fetch and process TPF secondary market data directly from the ANBIMA website.
+    Only the last 5 days of data are available in the ANBIMA website.
 
     This function retrieves bond market data from the ANBIMA website for a
     specified reference date. It handles different file formats based on the date

{pyield-0.31.0 → pyield-0.31.2}/pyield/tpf/lft.py

@@ -3,7 +3,7 @@ import pandas as pd
 from pyield import anbima, bday
 from pyield import date_converter as dc
 from pyield.date_converter import DateScalar
-from pyield.tpf import tools as tt
+from pyield.tpf import tools
 
 
 def data(date: DateScalar) -> pd.DataFrame:
@@ -22,8 +22,8 @@ def data(date: DateScalar) -> pd.DataFrame:
             - Price: The price of the LFT bond.
 
     Examples:
-
-        >>> yd.lft.data("23-08-2024")
+        >>> from pyield import lft
+        >>> lft.data("23-08-2024")
            ReferenceDate BondType MaturityDate  IndicativeRate         Price
         0     2024-08-23      LFT   2024-09-01        0.000272  15252.158852
         1     2024-08-23      LFT   2025-03-01       -0.000418  15255.605864
@@ -61,7 +61,8 @@ def quotation(
 
     Examples:
         Calculate the quotation of a LFT bond with a 0.02 yield rate:
-        >>> yd.lft.quotation(
+        >>> from pyield import lft
+        >>> lft.quotation(
         ...     settlement="24-07-2024",
         ...     maturity="01-09-2030",
         ...     rate=0.001717,  # 0.1717%
@@ -76,11 +77,11 @@ def quotation(
     bdays = bday.count(settlement, maturity)
 
     # Calculate the number of periods truncated as per Anbima rules
-    num_of_years = tt.truncate(bdays / 252, 14)
+    num_of_years = tools.truncate(bdays / 252, 14)
 
     discount_factor = 1 / (1 + rate) ** num_of_years
 
-    return tt.truncate(100 * discount_factor, 4)
+    return tools.truncate(100 * discount_factor, 4)
 
 
 def premium(lft_rate: float, selic_over: float) -> float:

{pyield-0.31.0 → pyield-0.31.2}/pyield/tpf/ltn.py

@@ -4,7 +4,7 @@ from pyield import anbima, bday
 from pyield import date_converter as dc
 from pyield.b3 import di
 from pyield.date_converter import DateScalar
-from pyield.tpf import tools as tt
+from pyield.tpf import tools
 
 FACE_VALUE = 1000
 
@@ -20,7 +20,8 @@ def data(date: DateScalar) -> pd.DataFrame:
         pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
 
     Examples:
-        >>> yd.ltn.data("23-08-2024")
+        >>> from pyield import ltn
+        >>> ltn.data("23-08-2024")
            ReferenceDate BondType MaturityDate  IndicativeRate       Price
         0     2024-08-23      LTN   2024-10-01        0.104416  989.415342
         1     2024-08-23      LTN   2025-01-01        0.107171  964.293046
@@ -51,7 +52,8 @@ def maturities(date: DateScalar) -> pd.Series:
         pd.Series: A Series of bond maturities available for the reference date.
 
     Examples:
-        >>> yd.ltn.maturities("22-08-2024")
+        >>> from pyield import ltn
+        >>> ltn.maturities("22-08-2024")
         0    2024-10-01
         1    2025-01-01
         2    2025-04-01
@@ -97,7 +99,8 @@ def price(
         - https://www.anbima.com.br/data/files/A0/02/CC/70/8FEFC8104606BDC8B82BA2A8/Metodologias%20ANBIMA%20de%20Precificacao%20Titulos%20Publicos.pdf
 
     Examples:
-        >>> yd.ltn.price("05-07-2024", "01-01-2030", 0.12145)
+        >>> from pyield import ltn
+        >>> ltn.price("05-07-2024", "01-01-2030", 0.12145)
         535.279902
     """
 
@@ -109,12 +112,12 @@ def price(
     bdays = bday.count(settlement, maturity)
 
     # Calculate the number of periods truncated as per Anbima rule
-    num_of_years = tt.truncate(bdays / 252, 14)
+    num_of_years = tools.truncate(bdays / 252, 14)
 
     discount_factor = (1 + rate) ** num_of_years
 
     # Truncate the price to 6 decimal places as per Anbima rules
-    return tt.truncate(FACE_VALUE / discount_factor, 6)
+    return tools.truncate(FACE_VALUE / discount_factor, 6)
 
 
 def di_spreads(date: DateScalar) -> pd.DataFrame:
@@ -132,7 +135,8 @@ def di_spreads(date: DateScalar) -> pd.DataFrame:
         pd.DataFrame: DataFrame with the columns "MaturityDate" and "DISpread" (in bps).
 
     Examples:
-        >>> yd.ltn.di_spreads("22-08-2024")
+        >>> from pyield import ltn
+        >>> ltn.di_spreads("22-08-2024")
            MaturityDate  DISpread
         0    2024-10-01     -3.06
         1    2025-01-01     -9.95
@@ -149,7 +153,7 @@ def di_spreads(date: DateScalar) -> pd.DataFrame:
         12   2030-01-01     14.96
     """
     # Fetch DI Spreads for the reference date
-    df = tt.pre_spreads(date)
+    df = tools.pre_spreads(date)
     df.query("BondType == 'LTN'", inplace=True)
     df.sort_values(["MaturityDate"], ignore_index=True, inplace=True)
     return df[["MaturityDate", "DISpread"]]
@@ -170,7 +174,8 @@ def premium(ltn_rate: float, di_rate: float) -> float:
         Reference date: 22-08-2024
         LTN rate for 01-01-2030: 0.118746
         DI (JAN30) Settlement rate: 0.11725
-        >>> yd.ltn.premium(0.118746, 0.11725)
+        >>> from pyield import ltn
+        >>> ltn.premium(0.118746, 0.11725)
         1.0120718007994287
     """
     # Cálculo das taxas diárias
@@ -197,7 +202,8 @@ def historical_premium(
                If the data is not available, returns NaN.
 
     Examples:
-        >>> yd.ltn.historical_premium("22-08-2024", "01-01-2030")
+        >>> from pyield import ltn
+        >>> ltn.historical_premium("22-08-2024", "01-01-2030")
         1.0120718007994287
 
     """

{pyield-0.31.0 → pyield-0.31.2}/pyield/tpf/ntnb.py

@@ -34,7 +34,8 @@ def data(date: DateScalar) -> pd.DataFrame:
         - IndicativeRate: The indicative rate for the bond.
 
     Examples:
-        >>> yd.ntnb.data("23-08-2024")
+        >>> from pyield import ntnb
+        >>> ntnb.data("23-08-2024")
            ReferenceDate BondType MaturityDate  IndicativeRate        Price
         0     2024-08-23    NTN-B   2025-05-15        0.063804  4377.008543
         1     2024-08-23    NTN-B   2026-08-15        0.065795  4278.316344
@@ -66,8 +67,8 @@ def maturities(date: DateScalar) -> pd.Series:
         pd.Series: Series containing the maturity dates for the NTN-B bonds.
 
     Examples:
-
-        >>> yd.ntnb.maturities("16-08-2024")
+        >>> from pyield import ntnb
+        >>> ntnb.maturities("16-08-2024")
         0    2025-05-15
         1    2026-08-15
         2    2027-05-15
@@ -147,7 +148,8 @@ def payment_dates(
         pd.Series: Series of coupon dates within the specified range.
 
     Examples:
-        >>> yd.ntnb.payment_dates("10-05-2024", "15-05-2025")
+        >>> from pyield import ntnb
+        >>> ntnb.payment_dates("10-05-2024", "15-05-2025")
         0   2024-05-15
         1   2024-11-15
         2   2025-05-15
@@ -194,7 +196,8 @@ def cash_flows(
         - CashFlow: Cash flow value for the bond
 
     Examples:
-        >>> yd.ntnb.cash_flows("10-05-2024", "15-05-2025")
+        >>> from pyield import ntnb
+        >>> ntnb.cash_flows("10-05-2024", "15-05-2025")
           PaymentDate    CashFlow
         0  2024-05-15    2.956301
         1  2024-11-15    2.956301
@@ -238,11 +241,12 @@ def quotation(
           Anbima rules.
 
     Examples:
-        >>> yd.ntnb.quotation("31-05-2024", "15-05-2035", 0.061490)
+        >>> from pyield import ntnb
+        >>> ntnb.quotation("31-05-2024", "15-05-2035", 0.061490)
         99.3651
-        >>> yd.ntnb.quotation("31-05-2024", "15-08-2060", 0.061878)
+        >>> ntnb.quotation("31-05-2024", "15-08-2060", 0.061878)
         99.5341
-        >>> yd.ntnb.quotation("15-08-2024", "15-08-2032", 0.05929)
+        >>> ntnb.quotation("15-08-2024", "15-08-2032", 0.05929)
         100.6409
     """
     # Validate and normalize dates
@@ -286,9 +290,10 @@ def price(
         - https://www.anbima.com.br/data/files/A0/02/CC/70/8FEFC8104606BDC8B82BA2A8/Metodologias%20ANBIMA%20de%20Precificacao%20Titulos%20Publicos.pdf
 
     Examples:
-        >>> yd.ntnb.price(4299.160173, 99.3651)
+        >>> from pyield import ntnb
+        >>> ntnb.price(4299.160173, 99.3651)
         4271.864805
-        >>> yd.ntnb.price(4315.498383, 100.6409)
+        >>> ntnb.price(4315.498383, 100.6409)
         4343.156412
     """
     return bt.truncate(vna * quotation / 100, 6)
@@ -319,11 +324,11 @@ def spot_rates(
         pd.DataFrame: DataFrame with columns "MaturityDate", "SpotRate".
 
     Examples:
-        # Get the NTN-B rates for a specific reference date
-        >>> df = yd.ntnb.data("16-08-2024")
-
-        # Calculate the spot rates considering the settlement at the reference date
-        >>> yd.ntnb.spot_rates(
+        >>> from pyield import ntnb
+        >>> # Get the NTN-B rates for a specific reference date
+        >>> df = ntnb.data("16-08-2024")
+        >>> # Calculate the spot rates considering the settlement at the reference date
+        >>> ntnb.spot_rates(
         ...     settlement="16-08-2024",
         ...     maturities=df["MaturityDate"],
         ...     rates=df["IndicativeRate"],
@@ -521,6 +526,22 @@ def duration(
     maturity: DateScalar,
     rate: float,
 ) -> float:
+    """
+    Calculate the Macaulay duration of the NTN-B bond in business years.
+
+    Args:
+        settlement (DateScalar): The settlement date of the operation.
+        maturity (DateScalar): The maturity date of the NTN-B bond.
+        rate (float): The discount rate used to calculate the duration.
+
+    Returns:
+        float: The Macaulay duration of the NTN-B bond in business years.
+
+    Examples:
+        >>> from pyield import ntnb
+        >>> ntnb.duration("23-08-2024", "15-08-2060", 0.061005)
+        15.083054313130464
+    """
     settlement = dc.convert_input_dates(settlement)
     maturity = dc.convert_input_dates(maturity)
 

pyield-0.31.2/pyield/tpf/ntnc.py

@@ -0,0 +1,276 @@
+import numpy as np
+import pandas as pd
+
+import pyield.date_converter as dc
+import pyield.tpf.tools as bt
+from pyield import anbima, bday
+from pyield.date_converter import DateScalar
+
+"""
+Constants calculated as per Anbima Rules and in base 100
+Valid for NTN-C bonds with maturity date 01-01-2031:
+PRINCIPAL = 100
+COUPON_RATE = (0.12 + 1) ** 0.5 - 1  # 12% annual rate compounded semi-annually
+COUPON_PMT = round(100 * COUPON_RATE, 6) -> 5.830052
+FINAL_PMT = principal + last coupon payment = 100 + COUPON_PMT = 105.830052
+
+All other NTN-C bonds will have different values for COUPON_PMT and FINAL_PMT:
+COUPON_RATE = (0.06 + 1) ** 0.5 - 1  # 6% annual rate compounded semi-annually
+COUPON_PMT = round(100 * COUPON_RATE, 6) -> 2.956301
+FINAL_PMT = principal + last coupon payment = 100 + 2.956301
+
+"""
+COUPON_DAY = 1
+COUPON_PMT_2031 = 5.830052
+FINAL_PMT_2031 = 105.830052
+
+COUPON_PMT = 2.956301
+FINAL_PMT = 102.956301
+
+
+def _get_coupon_pmt(maturity: pd.Timestamp) -> float:
+    if maturity.year == 2031:  # noqa
+        return COUPON_PMT_2031
+    return COUPON_PMT
+
+
+def _get_final_pmt(maturity: pd.Timestamp) -> float:
+    if maturity.year == 2031:  # noqa
+        return FINAL_PMT_2031
+    return FINAL_PMT
+
+
+def data(date: DateScalar) -> pd.DataFrame:
+    """
+    Fetch the LTN Anbima indicative rates for the given reference date.
+
+    Args:
+        date (DateScalar): The reference date for fetching the data.
+
+    Returns:
+        pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
+
+    Examples:
+        >>> from pyield import ntnc
+        >>> ntnc.data("21-03-2025")
+          ReferenceDate BondType MaturityDate  IndicativeRate        Price
+        0    2025-03-21    NTN-C   2031-01-01        0.067626  8347.348705
+    """
+    return anbima.tpf_data(date, "NTN-C")
+
+
+def payment_dates(
+    settlement: DateScalar,
+    maturity: DateScalar,
+) -> pd.Series:
+    """
+    Generate all remaining coupon dates between a given date and the maturity date.
+    The dates are inclusive. The NTN-C bond is determined by its maturity date.
+
+    Args:
+        settlement (DateScalar): The settlement date (exlusive) to start generating
+            the coupon dates.
+        maturity (DateScalar): The maturity date.
+
+    Returns:
+        pd.Series: Series of coupon dates within the specified range.
+
+    Examples:
+        >>> from pyield import ntnc
+        >>> ntnc.payment_dates("21-03-2025", "01-01-2031")
+        0    2025-07-01
+        1    2026-01-01
+        2    2026-07-01
+        3    2027-01-01
+        4    2027-07-01
+        5    2028-01-01
+        6    2028-07-01
+        7    2029-01-01
+        8    2029-07-01
+        9    2030-01-01
+        10   2030-07-01
+        11   2031-01-01
+        dtype: datetime64[ns]
+    """
+    # Validate and normalize dates
+    settlement = dc.convert_input_dates(settlement)
+    maturity = dc.convert_input_dates(maturity)
+
+    # Check if maturity date is after the start date
+    if maturity < settlement:
+        raise ValueError("Maturity date must be after the start date.")
+
+    # Initialize loop variables
+    coupon_dates = maturity
+    cp_dates = []
+
+    # Iterate backwards from the maturity date to the settlement date
+    while coupon_dates > settlement:
+        cp_dates.append(coupon_dates)
+        # Move the coupon date back 6 months
+        coupon_dates -= pd.DateOffset(months=6)
+
+    return pd.Series(cp_dates).sort_values(ignore_index=True)
+
+
+def cash_flows(
+    settlement: DateScalar,
+    maturity: DateScalar,
+) -> pd.DataFrame:
+    """
+    Generate the cash flows for NTN-C bonds between the settlement and maturity dates.
+
+    Args:
+        settlement (DateScalar): The settlement date (exclusive) to start generating
+            the cash flows.
+        maturity (DateScalar): The maturity date of the bond.
+
+    Returns:
+        pd.DataFrame: DataFrame with columns "PaymentDate" and "CashFlow".
+
+    Returned columns:
+        - PaymentDate: The payment date of the cash flow
+        - CashFlow: Cash flow value for the bond
+
+    Examples:
+        >>> from pyield import ntnc
+        >>> ntnc.cash_flows("21-03-2025", "01-01-2031")
+           PaymentDate    CashFlow
+        0   2025-07-01    5.830052
+        1   2026-01-01    5.830052
+        2   2026-07-01    5.830052
+        3   2027-01-01    5.830052
+        4   2027-07-01    5.830052
+        5   2028-01-01    5.830052
+        6   2028-07-01    5.830052
+        7   2029-01-01    5.830052
+        8   2029-07-01    5.830052
+        9   2030-01-01    5.830052
+        10  2030-07-01    5.830052
+        11  2031-01-01  105.830052
+    """
+    # Validate and normalize dates
+    settlement = dc.convert_input_dates(settlement)
+    maturity = dc.convert_input_dates(maturity)
+
+    # Get the coupon dates between the settlement and maturity dates
+    p_dates = payment_dates(settlement, maturity)
+
+    # Get the right coupon payment and final payment values
+    coupon_pmt = _get_coupon_pmt(maturity)
+    final_pmt = _get_final_pmt(maturity)
+
+    # Set the cash flow at maturity to FINAL_PMT and the others to COUPON_PMT
+    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": p_dates, "CashFlow": cfs})
+
+
+def quotation(
+    settlement: DateScalar,
+    maturity: DateScalar,
+    rate: float,
+) -> float:
+    """
+    Calculate the NTN-C quotation in base 100 using Anbima rules.
+
+    Args:
+        settlement (DateScalar): The settlement date of the operation.
+        maturity (DateScalar): The maturity date of the NTN-C bond.
+        rate (float): The discount rate used to calculate the present value of
+            the cash flows, which is the yield to maturity (YTM) of the NTN-C.
+
+    Returns:
+        float: The NTN-C quotation truncated to 4 decimal places.
+
+    References:
+        - https://www.anbima.com.br/data/files/A0/02/CC/70/8FEFC8104606BDC8B82BA2A8/Metodologias%20ANBIMA%20de%20Precificacao%20Titulos%20Publicos.pdf
+        - The semi-annual coupon is set to 2.956301, which represents a 6% annual
+          coupon rate compounded semi-annually and rounded to 6 decimal places as per
+          Anbima rules.
+
+    Examples:
+        >>> from pyield import ntnc
+        >>> ntnc.quotation("21-03-2025", "01-01-2031", 0.067626)
+        126.4958
+    """
+    # Validate and normalize dates
+    settlement = dc.convert_input_dates(settlement)
+    maturity = dc.convert_input_dates(maturity)
+
+    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, cf_dates)
+
+    # Calculate the number of periods truncated as per Anbima rules
+    num_of_years = bt.truncate(bdays / 252, 14)
+
+    discount_factor = (1 + rate) ** num_of_years
+
+    # Calculate the present value of each cash flow (DCF) rounded as per Anbima rules
+    cf_present_value = (cf_values / discount_factor).round(10)
+
+    # Return the quotation (the dcf sum) truncated as per Anbima rules
+    return bt.truncate(cf_present_value.sum(), 4)
+
+
+def price(
+    vna: float,
+    quotation: float,
+) -> float:
+    """
+    Calculate the NTN-C price using Anbima rules.
+
+    price = VNA * quotation / 100
+
+    Args:
+        vna (float): The nominal value of the NTN-C bond.
+        quotation (float): The NTN-C quotation in base 100.
+
+    Returns:
+        float: The NTN-C price truncated to 6 decimal places.
+
+    References:
+        - https://www.anbima.com.br/data/files/A0/02/CC/70/8FEFC8104606BDC8B82BA2A8/Metodologias%20ANBIMA%20de%20Precificacao%20Titulos%20Publicos.pdf
+
+    Examples:
+        >>> from pyield import ntnc
+        >>> ntnc.price(6598.913723, 126.4958)
+        8347.348705
+    """
+    return bt.truncate(vna * quotation / 100, 6)
+
+
+def duration(
+    settlement: DateScalar,
+    maturity: DateScalar,
+    rate: float,
+) -> float:
+    """
+    Calculate the Macaulay duration of the NTN-C bond in business years.
+
+    Args:
+        settlement (DateScalar): The settlement date of the operation.
+        maturity (DateScalar): The maturity date of the NTN-C bond.
+        rate (float): The discount rate used to calculate the duration.
+
+    Returns:
+        float: The Macaulay duration of the NTN-C bond in business years.
+
+    Examples:
+        >>> from pyield import ntnc
+        >>> ntnc.duration("21-03-2025", "01-01-2031", 0.067626)
+        4.405363320448003
+    """
+    settlement = dc.convert_input_dates(settlement)
+    maturity = dc.convert_input_dates(maturity)
+
+    df = cash_flows(settlement, maturity)
+    df["BY"] = bday.count(settlement, df["PaymentDate"]) / 252
+    df["DCF"] = df["CashFlow"] / (1 + rate) ** df["BY"]
+    np_duration = (df["DCF"] * df["BY"]).sum() / df["DCF"].sum()
+    return float(np_duration)

{pyield-0.31.0 → pyield-0.31.2}/pyield/tpf/ntnf.py

@@ -8,7 +8,7 @@ from pyield import date_converter as dc
 from pyield import interpolator as ip
 from pyield.b3 import di
 from pyield.date_converter import DateScalar
-from pyield.tpf import tools as tt
+from pyield.tpf import tools
 
 """
 Constants calculated as per Anbima Rules
@@ -34,7 +34,8 @@ def data(date: DateScalar) -> pd.DataFrame:
         pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
 
     Examples:
-        >>> yd.ntnf.data("23-08-2024")
+        >>> from pyield import ntnf
+        >>> ntnf.data("23-08-2024")
           ReferenceDate BondType MaturityDate  IndicativeRate        Price
         0    2024-08-23    NTN-F   2025-01-01        0.107692  1011.189166
         1    2024-08-23    NTN-F   2027-01-01        0.115109   985.834842
@@ -57,7 +58,8 @@ def maturities(date: DateScalar) -> pd.Series:
         pd.Series: A Series of NTN-F bond maturities available for the reference date.
 
     Examples:
-        >>> yd.ntnf.maturities("23-08-2024")
+        >>> from pyield import ntnf
+        >>> ntnf.maturities("23-08-2024")
         0   2025-01-01
         1   2027-01-01
         2   2029-01-01
@@ -65,7 +67,6 @@ def maturities(date: DateScalar) -> pd.Series:
         4   2033-01-01
         5   2035-01-01
         dtype: datetime64[ns]
-
     """
     df_rates = data(date)
     s_maturities = df_rates["MaturityDate"]
@@ -106,8 +107,8 @@ def payment_dates(
             (exclusive) and maturity (inclusive) dates.
 
     Examples:
-
-        >>> yd.ntnf.payment_dates("15-05-2024", "01-01-2025")
+        >>> from pyield import ntnf
+        >>> ntnf.payment_dates("15-05-2024", "01-01-2025")
         0   2024-07-01
         1   2025-01-01
         dtype: datetime64[ns]
@@ -157,7 +158,8 @@ def cash_flows(
         pd.DataFrame: DataFrame with columns "PaymentDate" and "CashFlow".
 
     Examples:
-        >>> yd.ntnf.cash_flows("15-05-2024", "01-01-2025")
+        >>> from pyield import ntnf
+        >>> ntnf.cash_flows("15-05-2024", "01-01-2025")
           PaymentDate    CashFlow
         0  2024-07-01    48.80885
         1  2025-01-01  1048.80885
@@ -206,18 +208,19 @@ def price(
           Anbima rules.
 
     Examples:
-        >>> yd.ntnf.price("05-07-2024", "01-01-2035", 0.11921)
+        >>> from pyield import ntnf
+        >>> ntnf.price("05-07-2024", "01-01-2035", 0.11921)
         895.359254
     """
     cf_df = cash_flows(settlement, maturity)
     cf_values = cf_df["CashFlow"]
     bdays = bday.count(settlement, cf_df["PaymentDate"])
-    byears = tt.truncate(bdays / 252, 14)
+    byears = tools.truncate(bdays / 252, 14)
     discount_factors = (1 + rate) ** byears
     # Calculate the present value of each cash flow (DCF) rounded as per Anbima rules
     dcf = (cf_values / discount_factors).round(9)
     # Return the sum of the discounted cash flows truncated as per Anbima rules
-    return tt.truncate(dcf.sum(), 6)
+    return tools.truncate(dcf.sum(), 6)
 
 
 def spot_rates(  # noqa
@@ -254,9 +257,10 @@ def spot_rates(  # noqa
             "BDToMat" is the business days from the settlement date to the maturities.
 
     Examples:
-        >>> df_ltn = yd.ltn.data("03-09-2024")
-        >>> df_ntnf = yd.ntnf.data("03-09-2024")
-        >>> yd.ntnf.spot_rates(
+        >>> from pyield import ntnf, ltn
+        >>> df_ltn = ltn.data("03-09-2024")
+        >>> df_ntnf = ntnf.data("03-09-2024")
+        >>> ntnf.spot_rates(
         ...     settlement="03-09-2024",
         ...     ltn_maturities=df_ltn["MaturityDate"],
         ...     ltn_rates=df_ltn["IndicativeRate"],
@@ -306,7 +310,7 @@ def spot_rates(  # noqa
         # Calculate the present value of the coupon payments
         cf_dates = payment_dates(settlement, row["MaturityDate"])[:-1]  # noqa
         cf_df = df.query("MaturityDate in @cf_dates").reset_index(drop=True)
-        cf_present_value = tt.calculate_present_value(
+        cf_present_value = tools.calculate_present_value(
             cash_flows=cf_df["Coupon"],
             rates=cf_df["SpotRate"],
             periods=cf_df["BDToMat"] / 252,
@@ -339,7 +343,8 @@ def di_spreads(date: DateScalar) -> pd.DataFrame:
         pd.DataFrame: DataFrame with columns "MaturityDate", "DISpread".
 
     Examples:
-        >>> yd.ntnf.di_spreads("23-08-2024")
+        >>> from pyield import ntnf
+        >>> ntnf.di_spreads("23-08-2024")
           MaturityDate  DISpread
         0   2025-01-01     -5.38
         1   2027-01-01      4.39
@@ -350,7 +355,7 @@ def di_spreads(date: DateScalar) -> pd.DataFrame:
 
     """
     # Fetch DI Spreads for the reference date
-    df = tt.pre_spreads(date)
+    df = tools.pre_spreads(date)
     df = (
         df.query("BondType == 'NTN-F'")
         .sort_values(["MaturityDate"])
@@ -550,7 +555,7 @@ def premium(
     df["DIRate"] = df["BDToMat"].apply(ff_interpolator)
 
     # Calculate the present value of the cash flows using the DI rate
-    bond_price = tt.calculate_present_value(
+    bond_price = tools.calculate_present_value(
         cash_flows=df["CashFlow"],
         rates=df["DIRate"],
         periods=df["BDToMat"] / 252,
@@ -599,7 +604,7 @@ def historical_premium(
     )
 
     # Calculate the present value of the cash flows using the DI rate
-    bond_price = tt.calculate_present_value(
+    bond_price = tools.calculate_present_value(
         cash_flows=df["CashFlow"],
         rates=df["DIRate"],
         periods=df["BDToMat"] / 252,
@@ -625,11 +630,7 @@ def duration(
     rate: float,
 ) -> float:
     """
-    Calculate the Macaulay duration for an NTN-F bond.
-
-    The Macaulay duration is a weighted average of the times until each payment is
-    received, with the weights proportional to the present value of the cash flows.
-    It measures the bond's sensitivity to interest rate changes.
+    Calculate the Macaulay duration for an NTN-F bond in business years.
 
     Args:
         settlement (DateScalar): The settlement date to calculate the duration.
@@ -637,10 +638,11 @@ def duration(
         rate (float): The yield to maturity (YTM) used to discount the cash flows.
 
     Returns:
-        float: The Macaulay duration in years.
+        float: The Macaulay duration in business business years.
 
     Examples:
-        >>> yd.ntnf.duration("02-09-2024", "01-01-2035", 0.121785)
+        >>> from pyield import ntnf
+        >>> ntnf.duration("02-09-2024", "01-01-2035", 0.121785)
         6.32854218039796
     """
     settlement = dc.convert_input_dates(settlement)

{pyield-0.31.0 → pyield-0.31.2}/pyproject.toml

@@ -36,6 +36,7 @@ dev = [
     "types-requests", 
     "pandas-stubs",
     "lxml-stubs",
+    "ruff",
 ]
 
 [build-system]

pyield-0.31.0/pyield/__about__.py

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