PYield 0.35.7__tar.gz → 0.35.8__tar.gz

{pyield-0.35.7 → pyield-0.35.8}/PKG-INFO

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

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

{pyield-0.35.7 → pyield-0.35.8}/pyield/bday.py

@@ -135,6 +135,21 @@ def offset(
         1   2024-09-23
         dtype: datetime64[ns]
 
+        Null values are propagated
+
+        >>> bday.offset(pd.NaT, 1)  # NaT input
+        NaT
+
+        >>> bday.offset(pd.NaT, [1, 2])  # NaT input with a list of offsets
+        0   NaT
+        1   NaT
+        dtype: datetime64[ns]
+
+        >>> bday.offset(["19-09-2024", pd.NaT], 1)  # NaT in a list of dates
+        0   2024-09-20
+        1   NaT
+        dtype: datetime64[ns]
+
     Note:
         This function uses `numpy.busday_offset` under the hood, which means it follows
         the same conventions and limitations for business day calculations. For detailed
@@ -144,6 +159,14 @@ def offset(
     """
     dates_pd = dc.convert_input_dates(dates)
 
+    # Antecipate NaT handling
+    if dates_pd is pd.NaT:
+        if isinstance(offset, (list, tuple, np.ndarray, pd.Series)):
+            # If offset is a list, return a Series of NaT with the same length
+            return pd.Series([pd.NaT] * len(offset), dtype="datetime64[ns]")
+        else:
+            return pd.NaT
+
     if isinstance(dates_pd, pd.Series):
         # Divide the input in order to apply the correct holiday list
         old_dates = dates_pd[dates_pd < br_holidays.TRANSITION_DATE]
@@ -216,7 +239,7 @@ def count(start: DateScalar, end: DateArray) -> pd.Series: ...
 def count(start: DateArray, end: DateArray) -> pd.Series: ...
 
 
-def count(
+def count(  # noqa
     start: DateScalar | DateArray,
     end: DateScalar | DateArray,
 ) -> int | pd.Series:
@@ -278,65 +301,100 @@ def count(
         0    22
         1    19
         dtype: Int64
+
+        Null values are propagated
+
+        >>> bday.count(pd.NaT, "01-01-2024")  # NaT start
+        <NA>
+
+        >>> bday.count("01-01-2024", pd.NaT)  # NaT end
+        <NA>
+
+        >>> bday.count("01-01-2024", ["01-02-2024", pd.NaT])  # NaT in end array
+        0    22
+        1    <NA>
+        dtype: Int64
+
+        Original pandas index is preserved
+
+        >>> start_dates = pd.Series(
+        ...     ["01-01-2024", "01-02-2024", "01-03-2024"],
+        ...     index=["a", "b", "c"],
+        ... )
+        >>> bday.count(start_dates, "01-01-2025")
+        a    253
+        b    231
+        c    212
+        dtype: Int64
     """
+    # Padroniza as entradas para objetos do Pandas
     start_pd = dc.convert_input_dates(start)
     end_pd = dc.convert_input_dates(end)
 
-    # If inputs are Series, check if they have different lengths
+    # 1. VALIDAÇÃO ESTRUTURAL
     if isinstance(start_pd, pd.Series) and isinstance(end_pd, pd.Series):
-        if start_pd.size != end_pd.size:
+        if len(start_pd) != len(end_pd):
             raise ValueError("Input Series must have the same length.")
+        if not start_pd.index.equals(end_pd.index):
+            raise ValueError("Input dates have different indices!")
 
-    # Only start is used to determine the holiday list
-    if isinstance(start_pd, pd.Series):
-        # Divide the input in order to apply the correct holiday list
-        start1 = start_pd[start_pd < br_holidays.TRANSITION_DATE]
-        start2 = start_pd[start_pd >= br_holidays.TRANSITION_DATE]
-        start3 = start_pd[start_pd.isna()]
-
-        # If end is a Series, it must be divided as well
-        if isinstance(end_pd, pd.Series):
-            end1 = end_pd[start1.index]
-            end2 = end_pd[start2.index]
-        else:
-            end1 = end_pd
-            end2 = end_pd
-
-        result1 = np.busday_count(
-            begindates=dc.to_numpy_date_type(start1),
-            enddates=dc.to_numpy_date_type(end1),
-            holidays=OLD_HOLIDAYS_ARRAY,
-        )
-        result2 = np.busday_count(
-            begindates=dc.to_numpy_date_type(start2),
-            enddates=dc.to_numpy_date_type(end2),
-            holidays=NEW_HOLIDAYS_ARRAY,
-        )
-
-        # Prepare results to be rejoined
-        result1 = pd.Series(result1, dtype="Int64")
-        result2 = pd.Series(result2, dtype="Int64")
-        # Convert the third result from NaT to NA
-        result3 = pd.Series(pd.NA, index=start3.index, dtype="Int64")
-
-        # Old index is used to rejoin the results
-        result1.index = start1.index
-        result2.index = start2.index
+    # 2. LÓGICA PRINCIPAL
+    is_scalar_input = not (
+        isinstance(start_pd, pd.Series) or isinstance(end_pd, pd.Series)
+    )
 
-        # Reorder the result to match the original input order
-        result = pd.concat([result1, result2, result3]).sort_index()
+    # --- CASO 1: AMBAS AS ENTRADAS SÃO ESCALARES ---
+    if is_scalar_input:
+        if pd.isna(start_pd) or pd.isna(end_pd):
+            return pd.NA
 
-    else:  # Start is a single date
+        holidays = br_holidays.get_holiday_array(start_pd)
         result = np.busday_count(
             begindates=dc.to_numpy_date_type(start_pd),
             enddates=dc.to_numpy_date_type(end_pd),
-            holidays=br_holidays.get_holiday_array(start_pd),
+            holidays=holidays,
         )
-        result = pd.Series(result, dtype="Int64")
+        return int(result)
 
-    if result.size == 1:
-        return int(result[0])
-    return result
+    # --- CASO 2: PELO MENOS UMA ENTRADA É UMA SÉRIE ---
+    else:
+        # Garante que ambas as variáveis sejam Series para alinhamento automático.
+        # O Pandas faz o "broadcast" do escalar para o tamanho da Series.
+        if not isinstance(start_pd, pd.Series):
+            # start escalar e end Series: cria uma Series de start com o índice de end.
+            start_pd = pd.Series(start_pd, index=end_pd.index)
+        if not isinstance(end_pd, pd.Series):
+            # end escalar e start Series: cria uma Series de end com o índice de start.
+            end_pd = pd.Series(end_pd, index=start_pd.index)
+
+        # 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")
+
+        # 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.
+        not_null_mask = start_pd.notna() & end_pd.notna()
+        mask_old_holidays = not_null_mask & (start_pd < br_holidays.TRANSITION_DATE)
+        mask_new_holidays = not_null_mask & (start_pd >= br_holidays.TRANSITION_DATE)
+
+        # Calcula e atribui os resultados para o subconjunto "OLD"
+        if mask_old_holidays.any():
+            result.loc[mask_old_holidays] = np.busday_count(
+                begindates=dc.to_numpy_date_type(start_pd[mask_old_holidays]),
+                enddates=dc.to_numpy_date_type(end_pd[mask_old_holidays]),
+                holidays=OLD_HOLIDAYS_ARRAY,
+            )
+
+        # Calcula e atribui os resultados para o subconjunto "NEW"
+        if mask_new_holidays.any():
+            result.loc[mask_new_holidays] = np.busday_count(
+                begindates=dc.to_numpy_date_type(start_pd[mask_new_holidays]),
+                enddates=dc.to_numpy_date_type(end_pd[mask_new_holidays]),
+                holidays=NEW_HOLIDAYS_ARRAY,
+            )
+
+        # As linhas onde not_null_mask era False já contêm o valor <NA> default.
+        return result
 
 
 def generate(

{pyield-0.35.7 → pyield-0.35.8}/pyield/date_converter.py

@@ -32,6 +32,12 @@ def convert_input_dates(dates: DateArray) -> pd.Series: ...
 def convert_input_dates(
     dates: DateScalar | DateArray,
 ) -> pd.Timestamp | pd.Series:
+    # Capturar apenas escalares nulos: a verificação `is True` é crucial,
+    # pois `pd.isna()` retorna um array booleano para entradas de array,
+    # e um array nunca é idêntico ao objeto singleton `True`.
+    if pd.isna(dates) is True:
+        return pd.NaT
+
     match dates:
         case str():
             validate_date_format(dates)
@@ -41,6 +47,7 @@ def convert_input_dates(
             return pd.Timestamp(dates).normalize()
 
         case pd.Series() | np.ndarray() | list() | tuple():
+            # Preserve input values making a copy
             result = pd.Series(dates)
 
             if result.empty:
@@ -48,14 +55,14 @@ def convert_input_dates(
 
             if pd.api.types.is_string_dtype(result):
                 # Check first element to validate date format
-                validate_date_format(result[0])
+                validate_date_format(result.iloc[0])
 
             return pd.to_datetime(result, dayfirst=True).astype("datetime64[ns]")
 
         case pd.DatetimeIndex():
             return pd.Series(dates).astype("datetime64[ns]")
 
-        case _:  # unreachable code
+        case _:
             raise ValueError("Invalid input type for 'dates'.")
 
 
@@ -71,7 +78,9 @@ def to_numpy_date_type(
     Returns:
         np.datetime64 | np.ndarray: The input dates in a numpy datetime64[D] format.
     """
-    if isinstance(dates, pd.Timestamp):
+    if pd.isna(dates) is True:
+        return np.datetime64("NaT")
+    elif isinstance(dates, pd.Timestamp) or dates is pd.NaT:
         return np.datetime64(dates, "D")
     elif isinstance(dates, pd.Series):
         return dates.to_numpy().astype("datetime64[D]")

{pyield-0.35.7 → pyield-0.35.8}/pyield/holidays/brholidays.py

@@ -58,7 +58,8 @@ class BrHolidays:
                 if isinstance(dates, pd.Timestamp):
                     earliest_date = dates
                 else:
-                    earliest_date = dates.min()
+                    # NaN values will be ignored for min date calculation
+                    earliest_date = dates.min(skipna=True)
 
                 if earliest_date < BrHolidays.TRANSITION_DATE:
                     holidays = self.old_holidays

{pyield-0.35.7 → pyield-0.35.8}/pyield/tn/auction.py

@@ -61,12 +61,12 @@ def benchmarks(include_history: bool = False) -> pd.DataFrame:
         >>> # Get historical benchmarks
         >>> df_history = tn.benchmarks(include_history=True)
         >>> df_history.head()
-            Benchmark MaturityDate BondType  StartDate    EndDate
+            Benchmark   MaturityDate BondType  StartDate    EndDate
         0  LFT 6 anos   2020-03-01      LFT 2014-01-01 2014-06-30
         1  LFT 6 anos   2020-09-01      LFT 2014-07-01 2014-12-31
         2  LFT 6 anos   2021-03-01      LFT 2015-01-01 2015-04-30
         3  LFT 6 anos   2021-09-01      LFT 2015-05-01 2015-12-31
-        4   LFT 1 ano   2022-03-01      LFT 2020-10-15 2021-03-31
+        4  LFT 6 anos   2022-03-01      LFT 2016-01-01 2016-06-30
     """
     session = requests.Session()
     include_history_param_value = "S" if include_history else "N"

pyield-0.35.7/pyield/__about__.py

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