PYield 0.37.1__tar.gz → 0.37.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.37.1
+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.1 → 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.1 → pyield-0.37.2}/pyield/anbima/tpf.py

@@ -107,9 +107,7 @@ def _process_raw_df(df_raw: pd.DataFrame) -> pd.DataFrame:
 
 
 def _process_dv01(df: pd.DataFrame) -> pd.DataFrame:
-    df["BDToMat"] = bday.count(
-        start=df["ReferenceDate"], end=df["MaturityDate"]
-    ).astype("int64[pyarrow]")
+    df["BDToMat"] = bday.count(start=df["ReferenceDate"], end=df["MaturityDate"])
 
     df["Duration"] = 0.0
     df["Duration"] = df["Duration"].astype("float64[pyarrow]")

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

@@ -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)

{pyield-0.37.1 → 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.1 → 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.1 → 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.1 → pyield-0.37.2}/pyield/bc/auction.py

@@ -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
 

{pyield-0.37.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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")
 
@@ -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.1 → pyield-0.37.2}/pyield/tn/ntnf.py

@@ -322,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.1 → 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.1/pyield/__about__.py

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