PYield 0.32.7__tar.gz → 0.32.8__tar.gz

{pyield-0.32.7 → pyield-0.32.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.32.7
+Version: 0.32.8
 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.32.8/pyield/__about__.py

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

{pyield-0.32.7 → pyield-0.32.8}/pyield/b3/futures/historical.py

@@ -204,7 +204,7 @@ def process_df(
     df["BDaysToExp"] = bday.count(date, df["ExpirationDate"])
 
     # Remove expired contracts
-    df.query("DaysToExp > 0", inplace=True)
+    df = df.query("DaysToExp > 0").reset_index(drop=True)
 
     # Columns where 0 means NaN
     cols_with_nan = [col for col in df.columns if "Rate" in col]

{pyield-0.32.7 → pyield-0.32.8}/pyield/b3/futures/intraday.py

@@ -123,6 +123,9 @@ def _process_df(raw_df: pd.DataFrame, contract_code: str) -> pd.DataFrame:
     # 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)
+
     # The "FinancialVolume" column is in BRL, so we need to round it to cents
     df["FinancialVolume"] = df["FinancialVolume"].round(2)
 

{pyield-0.32.7 → pyield-0.32.8}/pyield/b3/futures/xml.py

@@ -205,8 +205,9 @@ def _process_df(df_raw: pd.DataFrame) -> pd.DataFrame:
     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.query("DaysToExp > 0", inplace=True)
+    df = df.query("DaysToExp > 0").reset_index(drop=True)
 
     df["BDaysToExp"] = bday.count(df["TradeDate"], df["ExpirationDate"])
 

{pyield-0.32.7 → pyield-0.32.8}/pyield/fwd.py

@@ -10,25 +10,25 @@ def forwards(
     Calcula taxas a termo (forward rates) a partir de taxas zero (spot rates).
 
     A taxa a termo no vértice 'n' é definida como:
-        fwdₙ = fwdₙ₋₁→ₙ (a taxa a termo de n-1 para n)
+        fwdₖ = fwdⱼ→ₖ (a taxa a termo de j para k)
 
     A fórmula utilizada é:
-        fwdₙ = ((1 + rₙ)^(duₙ/252) / (1 + rₙ₋₁)^(duₙ₋₁/252))^(252/(duₙ - duₙ₋₁)) - 1
+        fwdₖ = ((1 + rₖ)^(duₖ/252) / (1 + rⱼ)^(duⱼ/252))^(252/(duₖ - duⱼ)) - 1
 
     Como du/252 = t (tempo em anos úteis), a fórmula pode ser simplificada para:
 
-        fwdₙ = ((1 + rₙ)^tₙ / (1 + rₙ₋₁)^tₙ₋₁)^(1/(tₙ - tₙ₋₁)) - 1
+        fwdₖ = ((1 + rₖ)^tₖ / (1 + rⱼ)^tⱼ)^(1/(tₖ - tⱼ)) - 1
 
     Em LaTeX, a fórmula é representada como:
     $$
-    fwd_{n} = \left( \frac{(1 + r_n)^{t_n}}{(1 + r_{n-1})^{t_{n-1}}} \right)^{\frac{1}{t_n - t_{n-1}}} - 1
+    fwd_k = \left( \frac{(1 + r_k)^{t_k}}{(1 + r_j)^{t_j}} \right)^{\frac{1}{t_k - t_j}} - 1
     $$
 
     Onde:
-        - rₙ₋₁ é a taxa zero para o vértice anterior.
-        - rₙ é a taxa zero para o vértice atual.
-        - tₙ₋₁ é o prazo em anos para o vértice anterior (calculado como duₙ₋₁/252).
-        - tₙ é o prazo em anos para o vértice atual (calculado como duₙ/252).
+        - rⱼ é a taxa zero para o vértice anterior.
+        - rₖ é a taxa zero para o vértice atual.
+        - tⱼ é o prazo em anos para o vértice anterior (calculado como duⱼ/252).
+        - tₖ é o prazo em anos para o vértice atual (calculado como duₖ/252).
         - A constante 252 representa o número de dias úteis no ano.
 
     A primeira taxa a termo de cada grupo é definida como a
@@ -56,6 +56,10 @@ def forwards(
         pd.Series: Série contendo as taxas a termo calculadas (tipo Float64).
             A primeira taxa de cada grupo corresponde à taxa zero inicial.
 
+    Raises:
+        ValueError: Se os índices de `bdays` e `rates` não forem iguais.
+        ValueError: Se `groupby_dates` não for None e não tiver o mesmo tamanho
+
     Examples:
         >>> bdays = pd.Series([10, 20, 30])
         >>> rates = pd.Series([0.05, 0.06, 0.07])
@@ -64,47 +68,49 @@ def forwards(
         1    0.070095
         2    0.090284
         dtype: Float64
+
+    Note:
+        A função retorna uma série com o mesmo índice que `bdays` e `rates`.
     """  # noqa: E501
-    # Reset Series indexes to avoid misalignment issues during calculations
-    bdays = bdays.reset_index(drop=True).astype("Int64")
-    rates = rates.reset_index(drop=True).astype("Float64")
-    if groupby_dates is not None:
-        groupby_dates = groupby_dates.reset_index(drop=True)
+    bdays = bdays.astype("Int64")
+    rates = rates.astype("Float64")
+
+    # Check if indexes are the same
+    if not bdays.index.equals(rates.index):
+        raise ValueError("The indexes of bdays and rates must be the same.")
 
     # Create a DataFrame to work with the given series
-    df = pd.DataFrame({"du2": bdays, "r2": rates})
-    df["t2"] = df["du2"] / 252
+    df = pd.DataFrame({"duk": bdays, "rk": rates})
+    df["tk"] = df["duk"] / 252
 
-    # If no groupby_dates is provided, create a dummy column to group the DataFrame
-    if groupby_dates is not None:
+    if isinstance(groupby_dates, pd.Series):
+        if not groupby_dates.index.equals(bdays.index):
+            raise ValueError("groupby_dates index must be the same as bdays and rates.")
         df["groupby_date"] = groupby_dates
     else:
         df["groupby_date"] = 0  # Dummy value to group the DataFrame
 
     # Sort by the groupby_dates and t2 columns to ensure proper chronological order
-    df.sort_values(by=["groupby_date", "t2"], inplace=True)
+    df.sort_values(by=["groupby_date", "tk"], inplace=True)
 
     # Calculate the next zero rate and business day for each group
-    df["r1"] = df.groupby("groupby_date")["r2"].shift(1)
-    df["t1"] = df.groupby("groupby_date")["t2"].shift(1)
+    df["rj"] = df.groupby("groupby_date")["rk"].shift(1)
+    df["tj"] = df.groupby("groupby_date")["tk"].shift(1)
 
     # Calculate the formula components
-    factor_r2 = (1 + df["r2"]) ** df["t2"]  # (1 + r₂)^t₂
-    factor_r1 = (1 + df["r1"]) ** df["t1"]  # (1 + r₁)^t₁
-    time_exp = 1 / (df["t2"] - df["t1"])  # 1/(t₂ - t₁)
-
-    # f₁→₂ = ((1 + r₂)^t₂ / (1 + r₁)^t₁)^(1/(t₂ - t₁)) - 1
-    df["f1_2"] = (factor_r2 / factor_r1) ** time_exp - 1
+    # fₖ = fⱼ→ₖ = ((1 + rₖ)^tₖ / (1 + rⱼ)^tⱼ) ^ (1/(tₖ - tⱼ)) - 1
+    factor_rk = (1 + df["rk"]) ** df["tk"]  # (1 + rₖ)^tₖ
+    factor_rj = (1 + df["rj"]) ** df["tj"]  # (1 + rⱼ)^tⱼ
+    time_factor = 1 / (df["tk"] - df["tj"])  # 1/(tₖ - tⱼ)
+    df["fwd"] = (factor_rk / factor_rj) ** time_factor - 1
 
     # Identifify the first index of each group of dates
     first_indices = df.groupby("groupby_date").head(1).index
     # Set the first forward rate of each group to the zero rate
-    df.loc[first_indices, "f1_2"] = df.loc[first_indices, "r2"]
+    df.loc[first_indices, "fwd"] = df.loc[first_indices, "rk"]
 
-    # Return the forward rates as a Series
-    f1_2 = df["f1_2"]
-    f1_2.name = None
-    return f1_2
+    # Return the forward rates as a Series with no name
+    return df.loc[:, "fwd"]
 
 
 def forward(

{pyield-0.32.7 → pyield-0.32.8}/pyield/tpf/ltn.py

@@ -179,11 +179,11 @@ def premium(ltn_rate: float, di_rate: float) -> float:
         1.0120718007994287
     """
     # Cálculo das taxas diárias
-    ltn_factor = (1 + ltn_rate) ** (1 / 252)
-    di_factor = (1 + di_rate) ** (1 / 252)
+    ltn_daily_rate = (1 + ltn_rate) ** (1 / 252) - 1
+    di_daily_rate = (1 + di_rate) ** (1 / 252) - 1
 
     # Retorno do cálculo do prêmio
-    return (ltn_factor - 1) / (di_factor - 1)
+    return ltn_daily_rate / di_daily_rate
 
 
 def historical_premium(

pyield-0.32.7/pyield/__about__.py

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