PYield 0.37.0__tar.gz → 0.37.2__tar.gz

{pyield-0.37.0 → pyield-0.37.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.37.0
+Version: 0.37.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>

pyield-0.37.2/pyield/__about__.py

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

{pyield-0.37.0 → pyield-0.37.2}/pyield/anbima/ima.py

@@ -59,7 +59,7 @@ def _fetch_last_ima() -> pd.DataFrame:
         sep="@",
         decimal=",",
         thousands=".",
-        dtype_backend="numpy_nullable",
+        dtype_backend="pyarrow",
         na_values="--",
     )
 
@@ -69,10 +69,12 @@ def _fetch_last_ima() -> pd.DataFrame:
 def _process_last_ima(df: pd.DataFrame) -> pd.DataFrame:
     df = df.rename(columns=IMA_COL_MAPPING)[IMA_COL_MAPPING.values()]
     df["IndicativeRate"] = (df["IndicativeRate"] / 100).round(6)
-    df["Date"] = pd.to_datetime(df["Date"], format="%d/%m/%Y")
-    df["Maturity"] = pd.to_datetime(df["Maturity"], format="%d/%m/%Y")
-    df["MarketQuantity"] = (1000 * df["MarketQuantity"]).astype("Int64")
-    df["MarketValue"] = (1000 * df["MarketValue"]).round(0).astype("Int64")
+    df["Date"] = pd.to_datetime(df["Date"], format="%d/%m/%Y").astype("date32[pyarrow]")
+    df["Maturity"] = pd.to_datetime(df["Maturity"], format="%d/%m/%Y").astype(
+        "date32[pyarrow]"
+    )
+    df["MarketQuantity"] = (1000 * df["MarketQuantity"]).astype("int64[pyarrow]")
+    df["MarketValue"] = (1000 * df["MarketValue"]).round(0).astype("int64[pyarrow]")
     df["Price"] = df["Price"].round(6)
     # Duration is in business days, convert to years
     df["Duration"] /= 252
@@ -81,7 +83,9 @@ def _process_last_ima(df: pd.DataFrame) -> pd.DataFrame:
     # LFT DV01 is zero
     df["DV01"] = df["DV01"].where(df["BondType"] != "LFT", 0)
     # Since MarketDV01 is the total stock value, we round them to integer
-    df["MarketDV01"] = (df["DV01"] * df["MarketQuantity"]).round(0).astype("Int64")
+    df["MarketDV01"] = (
+        (df["DV01"] * df["MarketQuantity"]).round(0).astype("int64[pyarrow]")
+    )
 
     return df
 

{pyield-0.37.0 → pyield-0.37.2}/pyield/anbima/tpf.py

@@ -8,9 +8,13 @@ from zoneinfo import ZoneInfo
 import pandas as pd
 
 from pyield import bday
+from pyield.bc.ptax_api import ptax
 from pyield.data_cache import get_cached_dataset
 from pyield.date_converter import DateScalar, convert_input_dates
 from pyield.retry import default_retry
+from pyield.tn.ntnb import duration as duration_b
+from pyield.tn.ntnc import duration as duration_c
+from pyield.tn.ntnf import duration as duration_f
 
 BZ_TIMEZONE = ZoneInfo("America/Sao_Paulo")
 
@@ -64,7 +68,7 @@ def _read_raw_df(file_url: str) -> pd.DataFrame:
         decimal=",",
         thousands=".",
         na_values=["--"],
-        dtype_backend="numpy_nullable",
+        dtype_backend="pyarrow",
     )
     return df
 
@@ -96,15 +100,123 @@ def _process_raw_df(df_raw: pd.DataFrame) -> pd.DataFrame:
     # We will round to 6 decimal places to avoid floating point errors
     df[rate_cols] = (df[rate_cols] / 100).round(6)
 
-    df["ReferenceDate"] = pd.to_datetime(df["ReferenceDate"], format="%Y%m%d")
-    df["MaturityDate"] = pd.to_datetime(df["MaturityDate"], format="%Y%m%d")
-    df["IssueBaseDate"] = pd.to_datetime(df["IssueBaseDate"], format="%Y%m%d")
+    for col in ["ReferenceDate", "MaturityDate", "IssueBaseDate"]:
+        df[col] = pd.to_datetime(df[col], format="%Y%m%d").astype("date32[pyarrow]")
 
-    return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)
+    return df
+
+
+def _process_dv01(df: pd.DataFrame) -> pd.DataFrame:
+    df["BDToMat"] = bday.count(start=df["ReferenceDate"], end=df["MaturityDate"])
+
+    df["Duration"] = 0.0
+    df["Duration"] = df["Duration"].astype("float64[pyarrow]")
+
+    df_others = df.query(
+        "BondType not in ['LTN', 'NTN-F', 'NTN-B', 'NTN-C']"
+    ).reset_index(drop=True)
+
+    df_ltn = df.query("BondType == 'LTN'").reset_index(drop=True)
+    if not df_ltn.empty:
+        df_ltn["Duration"] = df_ltn["BDToMat"] / 252
+
+    df_ntnf = df.query("BondType == 'NTN-F'").reset_index(drop=True)
+    if not df_ntnf.empty:
+        df_ntnf["Duration"] = df_ntnf.apply(
+            lambda row: duration_f(
+                row["ReferenceDate"], row["MaturityDate"], row["IndicativeRate"]
+            ),
+            axis=1,
+        )
+
+    df_ntnb = df.query("BondType == 'NTN-B'").reset_index(drop=True)
+    if not df_ntnb.empty:
+        df_ntnb["Duration"] = df_ntnb.apply(
+            lambda row: duration_b(
+                row["ReferenceDate"], row["MaturityDate"], row["IndicativeRate"]
+            ),
+            axis=1,
+        )
+
+    df_ntnc = df.query("BondType == 'NTN-C'").reset_index(drop=True)
+    if not df_ntnc.empty:
+        df_ntnc["Duration"] = df_ntnc.apply(
+            lambda row: duration_c(
+                row["ReferenceDate"], row["MaturityDate"], row["IndicativeRate"]
+            ),
+            axis=1,
+        )
+
+    df = pd.concat([df_others, df_ltn, df_ntnf, df_ntnb, df_ntnc])
+    df["Duration"] = df["Duration"].astype("float64[pyarrow]")
+
+    mduration = df["Duration"] / (1 + df["IndicativeRate"])
+    df["DV01"] = 0.0001 * mduration * df["Price"]
+
+    return df
+
+
+def _add_usd_dv01(df: pd.DataFrame) -> pd.DataFrame:
+    """Add the USD DV01 column to the DataFrame."""
+    try:
+        reference_date = df["ReferenceDate"].iloc[0]
+        ptax_rate = ptax(date=reference_date)
+        df["DV01USD"] = df["DV01"] / ptax_rate
+    except Exception as e:
+        logger.error(f"Error adding USD DV01: {e}")
+    return df
+
+
+def _reorder_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """Reorder the columns of the DataFrame according to the specified order."""
+    column_order = [
+        "BondType",
+        "ReferenceDate",
+        "SelicCode",
+        "IssueBaseDate",
+        "MaturityDate",
+        "BDToMat",
+        "Duration",
+        "DV01",
+        "DV01USD",
+        "Price",
+        "BidRate",
+        "AskRate",
+        "IndicativeRate",
+        "StdDev",
+        "LowerBoundRateD0",
+        "UpperBoundRateD0",
+        "LowerBoundRateD1",
+        "UpperBoundRateD1",
+        "Criteria",
+    ]
+    column_order = [col for col in column_order if col in df.columns]
+    return df[column_order].copy()
+
+
+def _select_main_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """Select only the main columns from the DataFrame."""
+    main_columns = [
+        "BondType",
+        "ReferenceDate",
+        "MaturityDate",
+        "BDToMat",
+        "Duration",
+        "DV01",
+        "DV01USD",
+        "Price",
+        "BidRate",
+        "AskRate",
+        "IndicativeRate",
+    ]
+    main_columns = [col for col in main_columns if col in df.columns]
+    return df[main_columns].copy()
 
 
 def fetch_tpf_data(
-    date: DateScalar, bond_type: str | BOND_TYPES | None = None
+    date: DateScalar,
+    bond_type: str | BOND_TYPES | None = None,
+    all_columns: bool = True,
 ) -> pd.DataFrame:
     """Fetch and process TPF secondary market data directly from the ANBIMA website.
     This is a low-level function intended for internal use or specific backend
@@ -121,6 +233,8 @@ def fetch_tpf_data(
         date (DateScalar): The reference date for the data.
         bond_type (str, optional):  Filter data by bond type.
             Defaults to None, which returns data for all bond types.
+        all_columns (bool, optional):  If True, all columns are returned.
+            Defaults to True. If False, only the main columns are returned.
 
     Returns:
         pd.DataFrame: A DataFrame containing bond market data.
@@ -165,6 +279,13 @@ def fetch_tpf_data(
             )
             return df
         df = _process_raw_df(df)
+        df = _process_dv01(df)
+        df = _add_usd_dv01(df)
+        df = _reorder_columns(df)
+
+        if not all_columns:
+            df = _select_main_columns(df)
+
         if bond_type:
             norm_bond_type = _bond_type_mapping(bond_type)  # noqa
             df = df.query("BondType == @norm_bond_type").reset_index(drop=True)
@@ -215,8 +336,18 @@ def tpf_data(
             - MaturityDate: The maturity date of the bond.
             - IndicativeRate: The indicative rate of the bond.
             - Price: The price (PU) of the bond.
-    """
 
+    Examples:
+        >>> from pyield import anbima
+        >>> anbima.tpf_data(date="22-08-2025")
+           ReferenceDate BondType MaturityDate  IndicativeRate         Price
+        0     2025-08-22      LFT   2025-09-01        0.000165  17200.957952
+        1     2025-08-22      LFT   2026-03-01       -0.000116  17202.058818
+        2     2025-08-22      LFT   2026-09-01       -0.000107  17202.901668
+        3     2025-08-22      LFT   2027-03-01        0.000302  17193.200289
+        4     2025-08-22      LFT   2027-09-01        0.000411  17186.767105
+        ...
+    """
     df = get_cached_dataset("tpf")
     date = convert_input_dates(date)
     df = df.query("ReferenceDate == @date").reset_index(drop=True)

{pyield-0.37.0 → pyield-0.37.2}/pyield/b3/di1.py

@@ -116,7 +116,7 @@ def data(
             return pd.DataFrame()
 
     if month_start:
-        df["ExpirationDate"] = df["ExpirationDate"].dt.to_period("M").dt.to_timestamp()
+        df["ExpirationDate"] = df["ExpirationDate"].dt.floor("MS")
 
     if not all_columns:
         cols = [
@@ -194,7 +194,7 @@ def interpolate_rates(
         0    0.13972
         1    0.134613
         2    <NA>
-        dtype: Float64
+        dtype: double[pyarrow]
 
         >>> # Interpolate rates for a single trade date and multiple expiration dates
         >>> # There is no DI Contract in 09-05-2025 with expiration 01-01-2050
@@ -206,7 +206,7 @@ def interpolate_rates(
         ... )
         0    0.13901
         1    0.13881
-        dtype: Float64
+        dtype: double[pyarrow]
 
         >>> # With extrapolation set to False, the second rate will be NaN
         >>> # Note: 0.13576348733268917 is shown as 0.135763
@@ -217,7 +217,7 @@ def interpolate_rates(
         ... )
         0    0.135763
         1    <NA>
-        dtype: Float64
+        dtype: double[pyarrow]
 
     Notes:
         - All available settlement rates are used for the flat-forward interpolation.
@@ -250,7 +250,7 @@ def interpolate_rates(
 
     # Initialize the interpolated rate column with NaN
     dfi["irate"] = pd.NA
-    dfi["irate"] = dfi["irate"].astype("Float64")
+    dfi["irate"] = dfi["irate"].astype("float64[pyarrow]")
 
     # Load DI rates dataset filtered by the provided reference dates
     dfr = data(dates=dates)
@@ -327,8 +327,8 @@ def interpolate_rate(
         >>> di1.interpolate_rate("25-04-2025", "01-01-2050", extrapolate=True)
         0.13881
     """
-    date = dc.convert_input_dates(date)
-    expiration = dc.convert_input_dates(expiration)
+    date = dc.convert_input_dates(date).date()
+    expiration = dc.convert_input_dates(expiration).date()
     if not date or not expiration:
         return float("NaN")
 
@@ -383,7 +383,7 @@ def eod_dates() -> pd.Series:
         2   1995-01-04
         3   1995-01-05
         4   1995-01-06
-        dtype: datetime64[ns]
+        dtype: date32[day][pyarrow]
     """
     available_dates = (
         get_cached_dataset("di1")

{pyield-0.37.0 → pyield-0.37.2}/pyield/b3/futures/historical.py

@@ -127,19 +127,19 @@ def _fetch_url_data(contract_code: str, date: pd.Timestamp) -> pd.DataFrame:
         thousands=".",
         decimal=",",
         na_values=["-"],
-        dtype_backend="numpy_nullable",
+        dtype_backend="pyarrow",
         encoding="iso-8859-1",
     )[0]
 
     # Remove rows and columns with all NaN values
-    df = df.dropna(axis=0, how="all").dropna(axis=1, how="all").copy()
+    df = df.dropna(axis=0, how="all").dropna(axis=1, how="all").reset_index(drop=True)
 
     # Force "VAR. PTOS." to be string, since it can also be read as float
-    df["VAR. PTOS."] = df["VAR. PTOS."].astype("string")
+    df["VAR. PTOS."] = df["VAR. PTOS."].astype("string[pyarrow]")
 
     # Force "AJUSTE CORRIG. (4)" to be float, since it can be also read as int
     if "AJUSTE CORRIG. (4)" in df.columns:
-        df["AJUSTE CORRIG. (4)"] = df["AJUSTE CORRIG. (4)"].astype("Float64")
+        df["AJUSTE CORRIG. (4)"] = df["AJUSTE CORRIG. (4)"].astype("float64[pyarrow]")
 
     return df
 
@@ -180,29 +180,32 @@ def _rename_columns(df: pd.DataFrame) -> pd.DataFrame:
     return df.rename(columns=rename_dict)
 
 
-def process_df(
-    input_df: pd.DataFrame, date: pd.Timestamp, contract_code: str
+def _process_df(
+    df: pd.DataFrame, date: pd.Timestamp, contract_code: str
 ) -> pd.DataFrame:
-    df = input_df.copy()
     df["TradeDate"] = date
-    # Convert to datetime64[ns] since it is pandas default type for timestamps
-    df["TradeDate"] = df["TradeDate"].astype("datetime64[ns]")
+    df["TradeDate"] = df["TradeDate"].astype("date32[pyarrow]")
     df["TickerSymbol"] = contract_code + df["ExpirationCode"]
 
     # Contract code format was changed in 22/05/2006
-    if date < pd.Timestamp("2006-05-22"):
-        df["ExpirationDate"] = df["ExpirationCode"].apply(
-            lambda code: get_old_expiration_date(code, date)
-        )  # type: ignore
+    code_format_change = pd.to_datetime("22-05-2006", dayfirst=True)
+    if date < code_format_change:
+        df["ExpirationDate"] = (
+            df["ExpirationCode"]
+            .apply(lambda code: get_old_expiration_date(code, date))
+            .astype("date32[pyarrow]")
+        )
     else:
         expiration_day = 15 if contract_code == "DAP" else 1
-        df["ExpirationDate"] = df["ExpirationCode"].apply(
-            lambda code: common.get_expiration_date(code, expiration_day)
-        )  # type: ignore
+        df["ExpirationDate"] = (
+            df["ExpirationCode"]
+            .apply(lambda code: common.get_expiration_date(code, expiration_day))
+            .astype("date32[pyarrow]")
+        )
 
     df["DaysToExp"] = (df["ExpirationDate"] - date).dt.days
     # Convert to nullable integer, since it is the default type in the library
-    df["DaysToExp"] = df["DaysToExp"].astype("Int64")
+    df["DaysToExp"] = df["DaysToExp"].astype("int64[pyarrow]")
 
     df["BDaysToExp"] = bday.count(date, df["ExpirationDate"])
 
@@ -218,7 +221,8 @@ def process_df(
 
     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 date <= pd.Timestamp("2002-01-17") and contract_code == "DI1":
+    switch_date = pd.to_datetime("17-01-2002", dayfirst=True)
+    if date <= switch_date and contract_code == "DI1":
         df = _adjust_older_contracts_rates(df, rate_cols)
     else:
         # Remove % and round to 5 (3 in %) dec. places in rate columns
@@ -244,7 +248,10 @@ def process_df(
         df["DV01"] = 0.0001 * modified_duration * df["SettlementPrice"]
 
     if contract_code in {"DI1", "DAP"}:  # Calculate forwards for DI1 and DAP contracts
-        df["ForwardRate"] = forwards(bdays=df["BDaysToExp"], rates=df["SettlementRate"])
+        df["ForwardRate"] = forwards(
+            bdays=df["BDaysToExp"],
+            rates=df["SettlementRate"],
+        )
 
     return df
 
@@ -276,7 +283,7 @@ def _select_and_reorder_columns(df: pd.DataFrame):
         "ForwardRate",
     ]
     reordered_columns = [col for col in all_columns if col in df.columns]
-    return df[reordered_columns]
+    return df[reordered_columns].copy()
 
 
 def fetch_bmf_data(contract_code: str, date: pd.Timestamp) -> pd.DataFrame:
@@ -305,6 +312,6 @@ def fetch_bmf_data(contract_code: str, date: pd.Timestamp) -> pd.DataFrame:
         return pd.DataFrame()
 
     df = _rename_columns(df_raw)
-    df = process_df(df, date, contract_code)
+    df = _process_df(df, date, contract_code)
     df = _select_and_reorder_columns(df)
     return df

{pyield-0.37.0 → pyield-0.37.2}/pyield/b3/futures/intraday.py

@@ -52,7 +52,7 @@ def _fetch_b3_df(contract_code: str) -> pd.DataFrame:
     df = pd.json_normalize(r.json()["Scty"])
 
     # Convert columns to the most appropriate data type
-    return df.convert_dtypes()
+    return df.convert_dtypes(dtype_backend="pyarrow")
 
 
 def _rename_columns(df: pd.DataFrame) -> pd.DataFrame:
@@ -89,10 +89,8 @@ def _rename_columns(df: pd.DataFrame) -> pd.DataFrame:
     return df
 
 
-def _process_df(raw_df: pd.DataFrame, contract_code: str) -> pd.DataFrame:
+def _process_df(df: pd.DataFrame, contract_code: str) -> pd.DataFrame:
     """Process the raw DataFrame from B3 API."""
-    df = raw_df.copy()
-
     # Clean and reformat the DataFrame columns
     df.columns = (df.columns
         .str.replace("SctyQtn.", "")
@@ -103,25 +101,30 @@ def _process_df(raw_df: pd.DataFrame, contract_code: str) -> pd.DataFrame:
     df = _rename_columns(df)
 
     # Convert maturity codes to datetime and drop rows with missing values
-    df["ExpirationDate"] = pd.to_datetime(df["ExpirationDate"], errors="coerce")
-    df.dropna(subset=["ExpirationDate"], inplace=True)
+    df["ExpirationDate"] = pd.to_datetime(df["ExpirationDate"], errors="coerce").astype(
+        "date32[pyarrow]"
+    )
 
     # Sort the DataFrame by maturity code and reset the index
-    df.sort_values("ExpirationDate", inplace=True, ignore_index=True)
+    df = (
+        df.dropna(subset=["ExpirationDate"])
+        .sort_values("ExpirationDate")
+        .reset_index(drop=True)
+    )
 
     # Get currante date in Brazil
     df["TradeDate"] = bday.last_business_day()
+    df["TradeDate"] = df["TradeDate"].astype("date32[pyarrow]")
 
     # Get current date and time
-    now = pd.Timestamp.now(BZ_TIMEZONE).round("s").tz_localize(None)
+    # now = pd.Timestamp.now(BZ_TIMEZONE).round("s").tz_localize(None)
+    now = dt.datetime.now(BZ_TIMEZONE)
     # Subtract 15 minutes from the current time to account for API delay
     df["LastUpdate"] = now - pd.Timedelta(minutes=15)
 
     df["BDaysToExp"] = bday.count(df["TradeDate"], df["ExpirationDate"])
 
     df["DaysToExp"] = (df["ExpirationDate"] - df["TradeDate"]).dt.days
-    # Convert to nullable integer, since it is the default type in the library
-    df["DaysToExp"] = df["DaysToExp"].astype("Int64")
 
     # Remove expired contracts
     df = df.query("DaysToExp >= 0").reset_index(drop=True)
@@ -136,7 +139,7 @@ def _process_df(raw_df: pd.DataFrame, contract_code: str) -> pd.DataFrame:
     if contract_code in {"DI1", "DAP"}:  # Add LastPrice for DI1 and DAP
         byears = df["BDaysToExp"] / 252
         df["LastPrice"] = 100_000 / ((1 + df["LastRate"]) ** byears)
-        df["LastPrice"] = df["LastPrice"].round(2).astype("Float64")
+        df["LastPrice"] = df["LastPrice"].round(2)
         df["ForwardRate"] = forwards(bdays=df["BDaysToExp"], rates=df["LastRate"])
 
     if contract_code == "DI1":  # Add DV01 for DI1

{pyield-0.37.0 → pyield-0.37.2}/pyield/b3/futures/xml.py

@@ -150,7 +150,7 @@ def _create_df_from_data(di1_data: list) -> pd.DataFrame:
 
     # Convert to CSV and then back to pandas to get automatic type conversion
     file = io.StringIO(df.to_csv(index=False))
-    return pd.read_csv(file, dtype_backend="numpy_nullable")
+    return pd.read_csv(file, dtype_backend="pyarrow")
 
 
 def _rename_columns(df: pd.DataFrame) -> pd.DataFrame:
@@ -193,18 +193,18 @@ def _rename_columns(df: pd.DataFrame) -> pd.DataFrame:
 def _process_df(df_raw: pd.DataFrame) -> pd.DataFrame:
     df = df_raw.copy()
     # Convert to datetime64[ns] since it is pandas default type for timestamps
-    df["TradeDate"] = df["TradeDate"].astype("datetime64[ns]")
+    df["TradeDate"] = df["TradeDate"].astype("date32[pyarrow]")
 
     expiration_code = df["TickerSymbol"].str[3:]
     contract_code = df["TickerSymbol"].str[:3].loc[0]
     expiration_day = 15 if contract_code == "DAP" else 1
     df["ExpirationDate"] = expiration_code.apply(
         common.get_expiration_date, args=(expiration_day,)
-    )
+    ).astype("date32[pyarrow]")
 
     df["DaysToExp"] = (df["ExpirationDate"] - df["TradeDate"]).dt.days
     # Convert to nullable integer, since it is the default type in the library
-    df["DaysToExp"] = df["DaysToExp"].astype("Int64")
+    df["DaysToExp"] = df["DaysToExp"].astype("int64[pyarrow]")
 
     # Remove expired contracts
     df = df.query("DaysToExp > 0").reset_index(drop=True)

{pyield-0.37.0 → pyield-0.37.2}/pyield/bc/__init__.py

@@ -1,5 +1,6 @@
 from pyield.bc.auction import auctions
-from pyield.bc.bcdata import (
+from pyield.bc.ptax_api import ptax, ptax_series
+from pyield.bc.rates import (
     di_over,
     di_over_series,
     selic_over,
@@ -7,7 +8,6 @@ from pyield.bc.bcdata import (
     selic_target,
     selic_target_series,
 )
-from pyield.bc.ptax import ptax_series
 from pyield.bc.repo import repos
 from pyield.bc.trades_intraday import tpf_intraday_trades
 from pyield.bc.trades_monthly import tpf_monthly_trades
@@ -20,6 +20,7 @@ __all__ = [
     "ptax_series",
     "repos",
     "tpf_monthly_trades",
+    "ptax",
     "tpf_intraday_trades",
     "selic_over",
     "selic_over_series",

{pyield-0.37.0 → pyield-0.37.2}/pyield/bc/auction.py

@@ -15,7 +15,7 @@ import requests
 
 from pyield import bday
 from pyield import date_converter as dc
-from pyield.bc import ptax
+from pyield.bc import ptax_api as pt
 from pyield.date_converter import DateScalar
 from pyield.retry import default_retry
 from pyield.tn.ntnb import duration as duration_b
@@ -153,10 +153,7 @@ def _process_df(df: pd.DataFrame) -> pd.DataFrame:
     df["AvgPrice"] = df["AvgPrice"].where(keep_avg_price, adjusted_avg_price)
 
     # Usar a data de liquidação para calcular o número de dias úteis até o vencimento
-    df["BDToMat"] = bday.count(
-        start=df["Settlement"],
-        end=df["Maturity"],
-    ).astype("int64[pyarrow]")
+    df["BDToMat"] = bday.count(start=df["Settlement"], end=df["Maturity"])
 
     return df
 
@@ -220,7 +217,7 @@ def _add_dv01(df: pd.DataFrame) -> pd.DataFrame:
 
 def _get_ptax_df(start_date: dt.date, end_date: dt.date) -> pd.DataFrame:
     # A série de leilões começa em 2007
-    df = ptax.ptax_series(start=start_date, end=end_date)
+    df = pt.ptax_series(start=start_date, end=end_date)
     return df[["Date", "MidRate"]].rename(columns={"MidRate": "PTAX"})
 
 

pyield-0.37.0/pyield/bc/ptax.py → pyield-0.37.2/pyield/bc/ptax_api.py

@@ -100,17 +100,17 @@ def ptax_series(
     - Para consultar dados de um intervalo, forneça as datas de `start` e `end`.
     Exemplo:
 
-            `ptax_series(start='2024-10-20', end='2024-10-27')`
+            `ptax_series(start='20-10-2024', end='27-10-2024')`
 
     - Se apenas `start` for fornecido, a API do BC retornará dados a partir
     da data de `start` até a data mais recente disponível. Exemplo:
 
-            `ptax_series(start='2024-10-20')`
+            `ptax_series(start='20-10-2024')`
 
     - Se apenas `end` for fornecido, a API do BC retornará dados desde a data mais
     antiga disponível até a data de `end`. Exemplo:
 
-        `ptax_series(end='2024-10-27')`
+        `ptax_series(end='27-10-2024')`
 
     Série Histórica Completa:
 
@@ -197,3 +197,44 @@ def ptax_series(
     url += "&$format=text/csv"  # Adiciona o formato CSV ao final
 
     return _fetch_df_from_url(url)
+
+
+def ptax(date: DateScalar) -> float:
+    """Busca a cotação PTAX média de fechamento para uma data específica.
+
+    Esta função é um wrapper para a função `ptax_series`, otimizada para
+    buscar o valor de um único dia.
+
+    Args:
+        date (DateScalar): A data para a qual a cotação PTAX é desejada.
+            Pode ser uma string no formato "dd-mm-aaaa" ou um objeto date/datetime.
+
+    Returns:
+        float: O valor da PTAX (taxa média) para a data especificada.
+               Retorna `np.nan` se não houver cotação para a data
+               (ex: feriado, fim de semana ou data futura).
+
+    Examples:
+        >>> from pyield import bc
+        >>> # Busca a PTAX para um dia útil
+        >>> bc.ptax("22-08-2025")
+        5.4389
+
+        >>> # Busca a PTAX para um fim de semana (sem dados)
+        >>> ptax_rate_weekend = bc.ptax("23-08-2025")
+        >>> pd.isna(ptax_rate_weekend)
+        True
+    """
+    # Reutiliza a função ptax_series para buscar os dados para o dia específico.
+    # Definir start e end com a mesma data busca a cotação para aquele dia.
+    df_ptax = ptax_series(start=date, end=date)
+
+    # Se o DataFrame estiver vazio, significa que não há cotação para a data.
+    # Isso ocorre em fins de semana, feriados ou datas futuras.
+    if df_ptax.empty:
+        logger.warning(f"No PTAX data found for date: {date}")
+        return float("nan")
+
+    # A API retorna uma única linha para a cotação de fechamento de um dia.
+    # A coluna "MidRate" representa a PTAX de fechamento.
+    return df_ptax["MidRate"].iloc[0]

pyield-0.37.0/pyield/bc/bcdata.py → pyield-0.37.2/pyield/bc/rates.py

@@ -97,8 +97,10 @@ def _fetch_request(
 
         df = pd.DataFrame(data, dtype="string")
         df = df.rename(columns={"data": "Date", "valor": "Value"})
-        df["Date"] = pd.to_datetime(df["Date"], format="%d/%m/%Y")
-        df["Value"] = (df["Value"].astype("Float64")) / 100
+        df["Date"] = pd.to_datetime(df["Date"], format="%d/%m/%Y").astype(
+            "date32[pyarrow]"
+        )
+        df["Value"] = (df["Value"].astype("float64[pyarrow]")) / 100
 
         return df
 
@@ -240,7 +242,7 @@ def selic_over(date: DateScalar) -> float:
     df = selic_over_series(date, date)
     if df.empty:
         return float("nan")
-    return float(df.at[0, "Value"])
+    return round(df.at[0, "Value"], 4)
 
 
 def selic_target_series(

{pyield-0.37.0 → pyield-0.37.2}/pyield/bc/repo.py

@@ -44,7 +44,7 @@ def _load_from_url(url: str) -> pd.DataFrame:
     response.raise_for_status()
     return pd.read_csv(
         io.StringIO(response.text),
-        dtype_backend="numpy_nullable",
+        dtype_backend="pyarrow",
         decimal=",",
         date_format="%Y-%m-%d",
         parse_dates=["dataMovimento", "dataLiquidacao", "dataRetorno"],
@@ -58,9 +58,13 @@ def _pre_process_df(df: pd.DataFrame) -> pd.DataFrame:
 
 
 def _process_df(df: pd.DataFrame) -> pd.DataFrame:
+    df["Date"] = df["Date"].astype("date32[pyarrow]")
+    df["Settlement"] = df["Settlement"].astype("date32[pyarrow]")
     df["StartTime"] = pd.to_datetime(df["StartTime"], format="%H:%M").dt.time
     # AcceptedVolume é em milhares de reais -> converter para reais
-    df["AcceptedVolume"] = (1_000 * df["AcceptedVolume"]).round(0).astype("Int64")
+    df["AcceptedVolume"] = (
+        (1_000 * df["AcceptedVolume"]).round(0).astype("int64[pyarrow]")
+    )
 
     # Remove the percentage sign and round to 6 decimal places (4 decimal places in %)
     df["CutRate"] = (df["CutRate"] / 100).round(6)

{pyield-0.37.0 → pyield-0.37.2}/pyield/bday.py

@@ -292,19 +292,19 @@ def count(
         >>> bday.count(start="01-01-2024", end=["01-02-2024", "01-03-2024"])
         0    22
         1    41
-        dtype: Int64
+        dtype: int64[pyarrow]
 
         The remaining business days in January and February to the end of the year
         >>> bday.count(["01-01-2024", "01-02-2024"], "01-01-2025")
         0    253
         1    231
-        dtype: Int64
+        dtype: int64[pyarrow]
 
         The total business days in January and February of 2024
         >>> bday.count(["01-01-2024", "01-02-2024"], ["01-02-2024", "01-03-2024"])
         0    22
         1    19
-        dtype: Int64
+        dtype: int64[pyarrow]
 
         Null values are propagated
         >>> bday.count(pd.NaT, "01-01-2024")  # NaT start
@@ -316,7 +316,7 @@ def count(
         >>> bday.count("01-01-2024", ["01-02-2024", pd.NaT])  # NaT in end array
         0    22
         1    <NA>
-        dtype: Int64
+        dtype: int64[pyarrow]
 
         Original pandas index is preserved
         >>> start_dates = pd.Series(
@@ -327,7 +327,7 @@ def count(
         a    253
         b    231
         c    212
-        dtype: Int64
+        dtype: int64[pyarrow]
     """
     # Padroniza as entradas para objetos do Pandas
     start_pd = dc.convert_input_dates(start)
@@ -364,7 +364,7 @@ def count(
 
     # Inicializa a série de resultados com o índice correto e tipo que suporta NA.
     # Nulos nas entradas (start_pd ou end_pd) resultarão em NA aqui.
-    result = pd.Series(index=start_pd.index, dtype="Int64")
+    result = pd.Series(index=start_pd.index, dtype="int64[pyarrow]")
 
     # Cria máscaras para linhas não-nulas, divididas pelo calendário de feriados.
     # A lógica de feriados depende APENAS da data de início.

{pyield-0.37.0 → pyield-0.37.2}/pyield/data_cache.py

@@ -18,12 +18,12 @@ BASE_DATA_URL = f"{GIT_URL}/data"
 # Dicionário global para configurações dos datasets usando 'filename'
 DATASET_CONFIGS = {
     "di1": {
-        "filename": "b3_di.parquet",  # Apenas o nome do arquivo
+        "filename": "b3_di.parquet",
         "date_column": "TradeDate",
         "name": "Futuro de DI (B3)",
     },
     "tpf": {
-        "filename": "anbima_tpf.parquet",  # Apenas o nome do arquivo
+        "filename": "anbima_tpf.parquet",
         "date_column": "ReferenceDate",
         "name": "TPF (ANBIMA)",
     },
@@ -51,29 +51,34 @@ def _load_github_file(file_url: str) -> pd.DataFrame:
 
 @functools.lru_cache(maxsize=len(DATASET_CONFIGS))
 def _get_dataset_with_ttl(dataset_id: str, date_key: str) -> pd.DataFrame:
-    """Carrega o dataset a partir do ID e da chave de data. Cache expira diariamente."""
+    """
+    Função interna e cacheada. Sua única responsabilidade é carregar os dados
+    e colocá-los no cache.
+    """
     if dataset_id not in DATASET_CONFIGS:
         raise ValueError(f"Dataset com ID '{dataset_id}' não encontrado.")
 
     config = DATASET_CONFIGS[dataset_id]
     filename = config["filename"]
-    date_column = config["date_column"]
-    dataset_name = config.get("name", dataset_id)
-
-    # Constrói a URL completa
     full_url = f"{BASE_DATA_URL}/{filename}"
 
     try:
+        # Apenas carrega e retorna. O .copy() aqui é opcional, mas inofensivo.
         df = _load_github_file(full_url)
-        last_date = df[date_column].max().date()
-        logger.info(f"Dataset {dataset_name} carregado. Última data: {last_date}")
-        return df.copy()
-
+        return df
     except Exception:
-        logger.exception(f"Erro ao carregar dataset {dataset_name} ({dataset_id})")
-        raise  # Re-raise a exceção para que o chamador saiba que falhou
+        logger.exception(f"Erro ao carregar dataset {dataset_id}")
+        raise
 
 
 def get_cached_dataset(dataset_id: Literal["di1", "tpf"]) -> pd.DataFrame:
-    """Obtém um dataset configurado pelo seu ID. O cache expira diariamente."""
-    return _get_dataset_with_ttl(dataset_id.lower(), _get_today_date_key())
+    """
+    Obtém um dataset configurado pelo seu ID, garantindo que o cache
+    não seja modificado pelo chamador.
+    O cache expira diariamente.
+    """
+    # 1. Pega o DataFrame do cache (ou aciona o carregamento)
+    df_from_cache = _get_dataset_with_ttl(dataset_id.lower(), _get_today_date_key())
+
+    # 2. Retorna uma CÓPIA para o usuário. Este é o passo crucial de proteção.
+    return df_from_cache.copy()

{pyield-0.37.0 → pyield-0.37.2}/pyield/date_converter.py

@@ -43,7 +43,10 @@ def convert_input_dates(
             validate_date_format(dates)
             return pd.to_datetime(dates, dayfirst=True)
 
-        case dt.datetime() | dt.date() | np.datetime64() | pd.Timestamp():
+        case dt.date():
+            return pd.Timestamp(dates)
+
+        case dt.datetime() | np.datetime64() | pd.Timestamp():
             return pd.Timestamp(dates).normalize()
 
         case pd.Series() | np.ndarray() | list() | tuple():

{pyield-0.37.0 → pyield-0.37.2}/pyield/fwd.py

@@ -67,7 +67,7 @@ def forwards(
         0        0.05
         1    0.070095
         2    0.090284
-        dtype: Float64
+        dtype: double[pyarrow]
 
         >>> # Exemplo com agrupamento (a última está isolada em outro grupo)
         >>> groupby_dates = pd.Series([1, 1, 2])
@@ -75,7 +75,7 @@ def forwards(
         0    0.05
         1    0.070095
         2    0.07
-        dtype: Float64
+        dtype: double[pyarrow]
 
     Note:
         - A função ordena os dados de entrada primeiro por `groupby_dates`,
@@ -83,8 +83,8 @@ def forwards(
         correta no cálculo das taxas a termo.
         - Os resultados são retornados na mesma ordem dos dados de entrada.
     """  # noqa: E501
-    bdays = bdays.astype("Int64")
-    rates = rates.astype("Float64")
+    bdays = bdays.astype("int64[pyarrow]")
+    rates = rates.astype("float64[pyarrow]")
 
     # Check if indexes are the same
     if not bdays.index.equals(rates.index):

{pyield-0.37.0 → pyield-0.37.2}/pyield/ibge/ipca.py

@@ -46,7 +46,7 @@ def _process_ipca_dataframe(
     else:
         df["Value"] = df["Value"].round(2)
 
-    df["Value"] = df["Value"].astype("Float64")
+    df["Value"] = df["Value"].astype("float64[pyarrow]")
     df["Period"] = pd.to_datetime(df["Period"], format="%Y%m").dt.to_period("M")
 
     return df

{pyield-0.37.0 → pyield-0.37.2}/pyield/tn/ltn.py

@@ -67,7 +67,7 @@ def maturities(date: DateScalar) -> pd.Series:
         10   2028-01-01
         11   2028-07-01
         12   2030-01-01
-        dtype: datetime64[ns]
+        dtype: date32[day][pyarrow]
 
     """
     df_rates = data(date)

{pyield-0.37.0 → pyield-0.37.2}/pyield/tn/ntnb.py

@@ -51,7 +51,6 @@ def data(date: DateScalar) -> pd.DataFrame:
         11    2024-08-23    NTN-B   2050-08-15         0.06114  4279.434119
         12    2024-08-23    NTN-B   2055-05-15        0.060892  4355.145036
         13    2024-08-23    NTN-B   2060-08-15        0.061005  4282.308398
-
     """
     return anbima.tpf_data(date, "NTN-B")
 
@@ -83,8 +82,7 @@ def maturities(date: DateScalar) -> pd.Series:
         11   2050-08-15
         12   2055-05-15
         13   2060-08-15
-        dtype: datetime64[ns]
-
+        dtype: date32[day][pyarrow]
     """
     df_rates = data(date)
     s_maturities = df_rates["MaturityDate"]
@@ -125,8 +123,8 @@ def _generate_all_coupon_dates(
     # First coupon date must be after the reference date, otherwise, it can lead to
     # division by zero where BDays == 0 (bootstrap method for instance)
     coupon_dates = coupon_dates[coupon_dates > start]
-
-    return pd.Series(coupon_dates).reset_index(drop=True)
+    coupon_dates = pd.Series(coupon_dates).astype("date32[pyarrow]")
+    return coupon_dates.reset_index(drop=True)
 
 
 def payment_dates(
@@ -153,7 +151,7 @@ def payment_dates(
         0   2024-05-15
         1   2024-11-15
         2   2025-05-15
-        dtype: datetime64[ns]
+        dtype: date32[day][pyarrow]
     """
     # Validate and normalize dates
     settlement = dc.convert_input_dates(settlement)
@@ -164,16 +162,17 @@ def payment_dates(
         raise ValueError("Maturity date must be after the start date.")
 
     # Initialize loop variables
-    coupon_dates = maturity
-    cp_dates = []
+    coupon_date = maturity
+    coupon_dates = []
 
     # Iterate backwards from the maturity date to the settlement date
-    while coupon_dates > settlement:
-        cp_dates.append(coupon_dates)
+    while coupon_date > settlement:
+        coupon_dates.append(coupon_date)
         # Move the coupon date back 6 months
-        coupon_dates -= pd.DateOffset(months=6)
+        coupon_date -= pd.DateOffset(months=6)
 
-    return pd.Series(cp_dates).sort_values(ignore_index=True)
+    coupon_dates = pd.Series(coupon_dates).astype("date32[pyarrow]")
+    return coupon_dates.sort_values().reset_index(drop=True)
 
 
 def cash_flows(
@@ -410,8 +409,8 @@ def spot_rates(
         df.at[index, "SpotRate"] = price_factor ** (1 / row["BYears"]) - 1
 
     df = df[["MaturityDate", "BDToMat", "SpotRate"]].copy()
-    # Force Float64 type in float columns to standardize the output
-    df["SpotRate"] = df["SpotRate"].astype("Float64")
+    # Force float64 type in float columns to standardize the output
+    df["SpotRate"] = df["SpotRate"].astype("float64[pyarrow]")
 
     # Filter the result without the intermediate coupon dates (virtual bonds)
     if not show_coupons:
@@ -506,7 +505,7 @@ def bei_rates(
         extrapolate=True,
     )
 
-    df["NIR"] = df["BDToMat"].apply(nir_interplator).astype("Float64")
+    df["NIR"] = df["BDToMat"].apply(nir_interplator).astype("float64[pyarrow]")
     # Calculate Breakeven Inflation Rate (BEI)
     df["BEI"] = ((df["NIR"] + 1) / (df["RIR"] + 1)) - 1
 

{pyield-0.37.0 → pyield-0.37.2}/pyield/tn/ntnc.py

@@ -90,7 +90,7 @@ def payment_dates(
         9    2030-01-01
         10   2030-07-01
         11   2031-01-01
-        dtype: datetime64[ns]
+        dtype: date32[day][pyarrow]
     """
     # Validate and normalize dates
     settlement = dc.convert_input_dates(settlement)
@@ -101,16 +101,17 @@ def payment_dates(
         raise ValueError("Maturity date must be after the start date.")
 
     # Initialize loop variables
-    coupon_dates = maturity
-    cp_dates = []
+    coupon_date = maturity
+    coupon_dates = []
 
     # Iterate backwards from the maturity date to the settlement date
-    while coupon_dates > settlement:
-        cp_dates.append(coupon_dates)
+    while coupon_date > settlement:
+        coupon_dates.append(coupon_date)
         # Move the coupon date back 6 months
-        coupon_dates -= pd.DateOffset(months=6)
+        coupon_date -= pd.DateOffset(months=6)
 
-    return pd.Series(cp_dates).sort_values(ignore_index=True)
+    coupon_dates = pd.Series(coupon_dates).astype("date32[pyarrow]")
+    return coupon_dates.sort_values().reset_index(drop=True)
 
 
 def cash_flows(

{pyield-0.37.0 → pyield-0.37.2}/pyield/tn/ntnf.py

@@ -66,7 +66,7 @@ def maturities(date: DateScalar) -> pd.Series:
         3   2031-01-01
         4   2033-01-01
         5   2035-01-01
-        dtype: datetime64[ns]
+        dtype: date32[day][pyarrow]
     """
     df_rates = data(date)
     s_maturities = df_rates["MaturityDate"]
@@ -111,7 +111,7 @@ def payment_dates(
         >>> ntnf.payment_dates("15-05-2024", "01-01-2025")
         0   2024-07-01
         1   2025-01-01
-        dtype: datetime64[ns]
+        dtype: date32[day][pyarrow]
     """
     # Validate and normalize dates
     settlement = dc.convert_input_dates(settlement)
@@ -135,7 +135,8 @@ def payment_dates(
         coupon_date -= pd.DateOffset(months=6)
 
     # Return the coupon dates as a sorted Series
-    return pd.Series(coupon_dates).sort_values(ignore_index=True)
+    coupon_dates = pd.Series(coupon_dates).astype("date32[pyarrow]")
+    return coupon_dates.sort_values().reset_index(drop=True)
 
 
 def cash_flows(
@@ -276,7 +277,7 @@ def spot_rates(  # noqa
         5   2035-01-01     2587  0.121398
     """
     # Process and validate the input data
-    settlement = dc.convert_input_dates(settlement)
+    settlement = dc.convert_input_dates(settlement).date()
 
     # Create flat forward interpolators for LTN and NTN-F rates
     ltn_rate_interpolator = ip.Interpolator(
@@ -321,7 +322,7 @@ def spot_rates(  # noqa
         df.at[index, "SpotRate"] = price_factor ** (1 / row["BYears"]) - 1
 
     df = df[["MaturityDate", "BDToMat", "SpotRate"]].copy()
-    df["SpotRate"] = df["SpotRate"].astype("Float64")
+    df["SpotRate"] = df["SpotRate"].astype("float64[pyarrow]")
 
     if not show_coupons:
         df = df.query("MaturityDate in @ntnf_maturities").reset_index(drop=True)

{pyield-0.37.0 → pyield-0.37.2}/pyield/tn/pre.py

@@ -87,14 +87,14 @@ def spot_rates(date: DateScalar) -> pd.DataFrame:
         ltn_subset = _process_additional_ltn(date, ltn_not_in_ntnf)
 
         # Ensure consistent data types
-        ltn_subset["BDToMat"] = ltn_subset["BDToMat"].astype("int64")
-        df_spots["BDToMat"] = df_spots["BDToMat"].astype("int64")
+        ltn_subset["BDToMat"] = ltn_subset["BDToMat"].astype("int64[pyarrow]")
+        df_spots["BDToMat"] = df_spots["BDToMat"].astype("int64[pyarrow]")
 
         # Combine LTN and NTN-F derived spot rates
         df_combined = pd.concat([df_spots, ltn_subset], ignore_index=True)
     else:
         df_combined = df_spots.copy()
-        df_combined["BDToMat"] = df_combined["BDToMat"].astype("int64")
+        df_combined["BDToMat"] = df_combined["BDToMat"].astype("int64[pyarrow]")
 
     # Final validation - ensure no NaN values in the result
     _validate_final_result(df_combined)

pyield-0.37.0/pyield/__about__.py

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