PYield 0.32.0__tar.gz → 0.32.2__tar.gz

{pyield-0.32.0 → pyield-0.32.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.32.0
+Version: 0.32.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>
@@ -34,7 +34,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Python: >=3.11
 Requires-Dist: numpy>=2.0.0
-Requires-Dist: pandas[html]>=2.0.0
+Requires-Dist: pandas[html,parquet]>=2.0.0
 Requires-Dist: requests>=2.31.0
 Requires-Dist: tenacity>=9.0.0
 Description-Content-Type: text/markdown

pyield-0.32.2/pyield/__about__.py

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

{pyield-0.32.0 → pyield-0.32.2}/pyield/anbima/tpf.py

@@ -5,7 +5,7 @@ from urllib.error import HTTPError
 import pandas as pd
 
 from pyield import bday
-from pyield.data_cache import get_tpf_dataset
+from pyield.data_cache import get_cached_dataset
 from pyield.date_converter import DateScalar, convert_input_dates
 from pyield.retry import default_retry
 
@@ -154,7 +154,7 @@ def tpf_data(
             - Price: The price (PU) of the bond.
     """
 
-    df = get_tpf_dataset()
+    df = get_cached_dataset("TPF")
     date = convert_input_dates(date)
     df = df.query("ReferenceDate == @date").reset_index(drop=True)
 

{pyield-0.32.0 → pyield-0.32.2}/pyield/b3/di.py

@@ -7,7 +7,7 @@ import pandas as pd
 import pyield.date_converter as dc
 import pyield.forward as fw
 from pyield import b3, bday, interpolator
-from pyield.data_cache import get_di_dataset, get_tpf_dataset
+from pyield.data_cache import get_cached_dataset
 from pyield.date_converter import DateArray, DateScalar
 
 logger = logging.getLogger(__name__)
@@ -78,7 +78,7 @@ class DIFutures:
         Returns a sorted series of unique trade dates available in the DI dataset.
         """
         return (
-            get_di_dataset()
+            get_cached_dataset("DI")
             .drop_duplicates(subset=["TradeDate"])["TradeDate"]
             .sort_values(ascending=True)
             .reset_index(drop=True)
@@ -110,21 +110,25 @@ class DIFutures:
 
     def _update_df(self) -> pd.DataFrame:
         """Retrieve DI contract DataFrame for the initialized trade date."""
-        if self._date is None:
+        if self.date is None:
             logger.info("No date specified. Returning empty DataFrame.")
             return pd.DataFrame()
         # Return an empty DataFrame if the trade date is a holiday
-        if not bday.is_business_day(self._date):
+        if not bday.is_business_day(self.date):
             logger.warning("Specified date is not a business day.")
             logger.warning("Returning empty DataFrame.")
             return pd.DataFrame()
 
         # Get historical data
-        df = get_di_dataset().query("TradeDate == @self._date").reset_index(drop=True)
+        df = (
+            get_cached_dataset("DI")
+            .query("TradeDate == @self.date")
+            .reset_index(drop=True)
+        )
 
         if df.empty:
             logger.info("No historical data found. Trying real-time data.")
-            df = b3.futures(contract_code="DI1", date=self._date)
+            df = b3.futures(contract_code="DI1", date=self.date)
 
         if df.empty:
             logger.warning("No DI Futures data found for the specified date.")
@@ -134,13 +138,11 @@ class DIFutures:
         if "DaysToExpiration" in df.columns:
             df.drop(columns=["DaysToExpiration"], inplace=True)
 
-        if self._pre_filter:
+        if self.pre_filter:
             df_pre = (
-                get_tpf_dataset()
+                get_cached_dataset("TPF")
                 .query("BondType in ['LTN', 'NTN-F']")
-                .query("ReferenceDate == @self._date")[
-                    ["ReferenceDate", "MaturityDate"]
-                ]
+                .query("ReferenceDate == @self.date")[["ReferenceDate", "MaturityDate"]]
                 .drop_duplicates()
                 .reset_index(drop=True)
             )
@@ -155,12 +157,12 @@ class DIFutures:
 
             df = df.merge(df_pre, how="inner")
 
-        if self._month_start:
+        if self.month_start:
             df["ExpirationDate"] = (
                 df["ExpirationDate"].dt.to_period("M").dt.to_timestamp()
             )
 
-        if not self._all_columns:
+        if not self.all_columns:
             cols = [
                 "TradeDate",
                 "TickerSymbol",
@@ -273,7 +275,7 @@ class DIFutures:
 
         # Load DI rates dataset filtered by the provided reference dates
         dfr = (
-            get_di_dataset()
+            get_cached_dataset("DI")
             .query("TradeDate in @dfi['tdate'].unique()")
             .reset_index(drop=True)
         )
@@ -316,8 +318,10 @@ class DIFutures:
     ) -> float:
         """Retrieve the DI rate for a specified expiration date."""
         expiration = dc.convert_input_dates(expiration)
+        if not self.date:
+            return float("NaN")
 
-        if self._month_start:
+        if self.month_start:
             # Force the expiration date to be the start of the month
             expiration = expiration.to_period("M").to_timestamp()
         else:
@@ -349,11 +353,11 @@ class DIFutures:
             known_rates=df["SettlementRate"],
             extrapolate=extrapolate,
         )
-        bd = bday.count(self._date, expiration)
+        bd = bday.count(self.date, expiration)
         return ff_interp(bd)
 
     @property
-    def date(self) -> pd.Timestamp:
+    def date(self) -> pd.Timestamp | None:
         """
         The trade date to retrieve the DI contract data.
 
@@ -363,7 +367,6 @@ class DIFutures:
         Returns:
             pd.Timestamp: The trade date set for this instance.
         """
-
         return self._date
 
     @date.setter

{pyield-0.32.0 → pyield-0.32.2}/pyield/bc/bcdata.py

@@ -19,6 +19,7 @@ from enum import Enum
 from urllib.error import HTTPError
 
 import pandas as pd
+import requests
 
 from pyield.date_converter import DateScalar, convert_input_dates
 from pyield.retry import default_retry
@@ -63,7 +64,7 @@ def _build_download_url(
         end_str = end.strftime("%d/%m/%Y")
 
     api_url = BASE_URL
-    api_url += f"{serie.value}/dados?formato=csv"
+    api_url += f"{serie.value}/dados?formato=json"
     api_url += f"&dataInicial={start_str}&dataFinal={end_str}"
 
     return api_url
@@ -91,16 +92,29 @@ def _fetch_data_from_url(
     api_url = _build_download_url(serie, start, end)
 
     try:
-        df = pd.read_csv(api_url, sep=";", decimal=",", dtype_backend="numpy_nullable")
+        response = requests.get(api_url, timeout=30)
+        response.raise_for_status()  # Raise exception for 4XX/5XX status codes
+        data = response.json()
+
+        if not data:
+            logger.warning(f"No data available for the requested period: {api_url}")
+            return pd.DataFrame()
+
+        # Convert JSON to DataFrame
+        df = pd.DataFrame(data)
+
         if df.empty or "valor" not in df.columns:
             logger.warning(f"No data available for the requested period: {api_url}")
             return pd.DataFrame()
 
         # Process the dataframe
+        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")
         # Value is in percentage format, so divide by 100
-        df["Value"] /= 100
+        df["Value"] = (df["Value"].astype("Float64")) / 100
+
         return df
     except HTTPError as e:
         if e.code == 404:  # noqa
@@ -142,10 +156,6 @@ def selic_over_series(
 
     Examples:
         >>> from pyield import bc
-        >>> bc.selic_over_series("31-05-2024", "31-05-2024")
-                Date  Value
-        0 2024-05-31  0.104
-
         >>> # No data on 26-01-2025 (sunday). Rate changed due to Copom meeting.
         >>> bc.selic_over_series("26-01-2025")  # Returns all data since 26-01-2025
                 Date   Value

{pyield-0.32.0 → pyield-0.32.2}/pyield/bday.py

@@ -8,7 +8,6 @@ import pyield.date_converter as dc
 import pyield.holidays as hl
 from pyield.date_converter import DateArray, DateScalar
 
-# Timezone for Brazil
 TIMEZONE_BZ = ZoneInfo("America/Sao_Paulo")
 
 IntegerScalar = int | np.integer
@@ -62,7 +61,12 @@ def offset(
 
     Args:
         dates (DateScalar | DateArray): The date(s) to offset. Can be a scalar date type
-            or a collection of dates. The holiday list is determined based on this date.
+            or a collection of dates. **Transition Handling:** Due to a change in
+            Brazilian national holidays effective from 2023-12-26 (`TRANSITION_DATE`),
+            this function automatically selects the appropriate holiday list
+            (old or new) based on **each individual date** in the `dates` input.
+            Dates before 2023-12-26 use the old list for their offset calculation,
+            while dates on or after 2023-12-26 use the new list.
         offset (int | Series | np.ndarray | list[int] | tuple[int], optional):
             The number of business days to offset the dates. Positive for future dates,
             negative for past dates. Zero will return the same date if it's a business
@@ -142,37 +146,40 @@ def offset(
 
     if isinstance(dates_pd, pd.Series):
         # Divide the input in order to apply the correct holiday list
-        dates1 = dates_pd[dates_pd < br_holidays.TRANSITION_DATE]
-        dates2 = dates_pd[dates_pd >= br_holidays.TRANSITION_DATE]
-        dates3 = dates_pd[dates_pd.isna()]
+        old_dates = dates_pd[dates_pd < br_holidays.TRANSITION_DATE]
+        new_dates = dates_pd[dates_pd >= br_holidays.TRANSITION_DATE]
+        # nat = NaT = Not a Time = missing value
+        nat_dates = dates_pd[dates_pd.isna()]
 
-        offsetted_dates1 = np.busday_offset(
-            dc.to_numpy_date_type(dates1),
+        offsetted_old_dates = np.busday_offset(
+            dc.to_numpy_date_type(old_dates),
             offsets=offset,
             roll=roll,
             holidays=OLD_HOLIDAYS_ARRAY,
         )
 
-        offsetted_dates2 = np.busday_offset(
-            dc.to_numpy_date_type(dates2),
+        offsetted_new_dates = np.busday_offset(
+            dc.to_numpy_date_type(new_dates),
             offsets=offset,
             roll=roll,
             holidays=NEW_HOLIDAYS_ARRAY,
         )
 
         # Convert from numpy.datetime64 to pandas.Timestamp
-        offsetted_dates1 = pd.to_datetime(offsetted_dates1)
-        offsetted_dates2 = pd.to_datetime(offsetted_dates2)
+        offsetted_old_dates = pd.to_datetime(offsetted_old_dates)
+        offsetted_new_dates = pd.to_datetime(offsetted_new_dates)
 
         # 'pd.to_datetime' does not necessarily return datetime64[ns] Series
-        offsetted_dates1 = pd.Series(offsetted_dates1).astype("datetime64[ns]")
-        offsetted_dates2 = pd.Series(offsetted_dates2).astype("datetime64[ns]")
+        offsetted_old_dates = pd.Series(offsetted_old_dates).astype("datetime64[ns]")
+        offsetted_new_dates = pd.Series(offsetted_new_dates).astype("datetime64[ns]")
 
         # Use old index to rejoin the results
-        offsetted_dates1.index = dates1.index
-        offsetted_dates2.index = dates2.index
+        offsetted_old_dates.index = old_dates.index
+        offsetted_new_dates.index = new_dates.index
 
-        offsetted_dates = pd.concat([offsetted_dates1, offsetted_dates2, dates3])
+        offsetted_dates = pd.concat(
+            [offsetted_old_dates, offsetted_new_dates, nat_dates]
+        )
 
         # Reorder the result to match the original input order
         return offsetted_dates.sort_index()
@@ -224,10 +231,13 @@ def count(
     applies to the calculation.
 
     Args:
-        start (DateScalar | DateArray): The start date(s) for counting. The holiday list
-            is selected based on this date.
-        end (DateScalar | DateArray): The end date(s) for counting, which
-            is excluded from the count themselves.
+        start (DateScalar | DateArray): The start date(s) for counting (inclusive).
+            **Transition Handling:** The holiday list used for the *entire* counting
+            period between `start` and `end` is determined solely by the `start` date's
+            relation to the holiday transition date (2023-12-26). If `start` is before
+            this date, the old holiday list is used for the whole count, even if `end`
+            is after it. If `start` is on or after this date, new holiday list is used.
+        end (DateScalar | DateArray): The end date(s) for counting (exclusive).
 
     Returns:
         int | pd.Series: Returns an integer if `start` and `end` are single dates,
@@ -235,20 +245,19 @@ def count(
 
     Notes:
         - This function is a wrapper around `numpy.busday_count`, adapted to work
-          directly with various Pandas and Numpy date formats.
+            directly with various Pandas and Numpy date formats.
         - It supports flexible date inputs, including single dates, lists, Series, and
-          more, for both `start` and `end` parameters.
+            more, for both `start` and `end` parameters.
         - The return type depends on the input types: single dates return an int, while
-          arrays of dates return a pd.Series with the count for each date range.
+            arrays of dates return a pd.Series with the count for each date range.
         - The `start` date determines the holiday list, ensuring consistency with the
-          applicable calendar at the time.
+            applicable calendar at the time.
         - See `numpy.busday_count` documentation for more details on how holidays are
-          handled and how business day counts are calculated:
-          https://numpy.org/doc/stable/reference/generated/numpy.busday_count.html.
+            handled and how business day counts are calculated:
+            https://numpy.org/doc/stable/reference/generated/numpy.busday_count.html.
 
     Examples:
         >>> from pyield import bday
-
         >>> bday.count("15-12-2023", "01-01-2024")
         10
 
@@ -334,7 +343,7 @@ def generate(
     start: DateScalar | None = None,
     end: DateScalar | None = None,
     inclusive: Literal["both", "neither", "left", "right"] = "both",
-    holiday_option: Literal["old", "new", "infer"] = "infer",
+    holiday_option: Literal["old", "new", "infer"] = "new",
 ) -> pd.Series:
     """
     Generates a Series of business days between a `start` and `end` date, considering
@@ -350,9 +359,14 @@ def generate(
             Determines which of the start and end dates are included in the result.
             Valid options are 'both', 'neither', 'left', 'right'. Defaults to 'both'.
         holiday_option (Literal["old", "new", "infer"], optional):
-            Specifies the list of holidays to consider. 'old' or 'new' refer to
-            predefined lists, 'infer' selects the list based on the most recent date in
-            the range. Defaults to "infer".
+            Specifies the list of holidays to consider. Defaults to "new".
+            - **'old'**: Uses the holiday list effective *before* the transition date
+            of 2023-12-26.
+            - **'new'**: Uses the holiday list effective *on and after* the transition
+            date of 2023-12-26.
+            - **'infer'**: Automatically selects the holiday list ('old' or 'new') based
+            on the `start` date relative to the transition date (2023-12-26). If `start`
+            is before the transition, 'old' is used; otherwise, 'new' is used.
 
     Returns:
         pd.Series: A Series representing a range of business days between the specified
@@ -384,7 +398,7 @@ def generate(
     else:
         end_pd = pd.Timestamp.today()
 
-    holidays_list = br_holidays.get_holiday_series(
+    applicable_holidays = br_holidays.get_holiday_series(
         dates=start_pd, holiday_option=holiday_option
     ).to_list()
 
@@ -394,8 +408,9 @@ def generate(
         end=end_pd,
         freq="C",
         inclusive=inclusive,
-        holidays=holidays_list,
+        holidays=applicable_holidays,
     )
+
     return pd.Series(result_dti.values)
 
 
@@ -413,9 +428,14 @@ def is_business_day(date: DateScalar) -> bool:
         >>> from pyield import bday
         >>> bday.is_business_day("25-12-2023")  # Christmas
         False
+
+    Notes:
+        - This function correctly identifies business days according to the applicable
+        Brazilian holiday list (before or after the 2023-12-26 transition), based
+        on the input `date`.
     """
     date_pd = dc.convert_input_dates(date)
-    shifted_date = offset(date_pd, 0)  # Shift the date if it is not a bus. day
+    shifted_date = offset(date_pd, 0)  # Shift the date if it is not a business day
     return date_pd == shifted_date
 
 
@@ -428,6 +448,11 @@ def last_business_day() -> pd.Timestamp:
     Returns:
         pd.Timestamp: The last business day in Brazil.
 
+    Notes:
+        - The determination of the last business day considers the correct Brazilian
+        holiday list (before or after the 2023-12-26 transition) applicable to
+        the current date.
+
     """
     # Get the current date in Brazil without timezone information
     bz_today = pd.Timestamp.now(TIMEZONE_BZ).normalize().tz_localize(None)

pyield-0.32.2/pyield/data_cache.py

@@ -0,0 +1,70 @@
+import functools
+import logging
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+import pandas as pd
+
+# --- Configurações Centralizadas ---
+TIMEZONE_BZ = ZoneInfo("America/Sao_Paulo")
+
+GIT_URL = "https://raw.githubusercontent.com/crdcj/pyield-data/main"
+# Diretório base onde os arquivos parquet estão localizados
+BASE_DATA_URL = f"{GIT_URL}/data"
+
+# Dicionário global para configurações dos datasets usando 'filename'
+DATASET_CONFIGS = {
+    "DI": {
+        "filename": "b3_di.parquet",  # Apenas o nome do arquivo
+        "date_column": "TradeDate",
+        "name": "Futuro de DI (B3)",
+    },
+    "TPF": {
+        "filename": "anbima_tpf.parquet",  # Apenas o nome do arquivo
+        "date_column": "ReferenceDate",
+        "name": "TPF (ANBIMA)",
+    },
+    # --- Adicionar futuros datasets aqui ---
+    # "NOVODATASET": {
+    #     "filename": "novo_dataset.parquet",
+    #     "date_column": "DataReferencia",
+    #     "name": "Novo Dataset Exemplo"
+    # },
+}
+
+logger = logging.getLogger(__name__)
+
+
+def _get_today_date_key():
+    """Retorna a data atual como string no formato YYYY-MM-DD."""
+    return datetime.now(TIMEZONE_BZ).strftime("%Y-%m-%d")
+
+
+@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."""
+    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:
+        df = pd.read_parquet(full_url)
+        last_date = df[date_column].max().date()
+        logger.info(f"Dataset {dataset_name} carregado. Última data: {last_date}")
+        return df.copy()
+
+    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
+
+
+def get_cached_dataset(dataset_id: str) -> pd.DataFrame:
+    """Obtém um dataset configurado pelo seu ID. O cache expira diariamente."""
+    return _get_dataset_with_ttl(dataset_id, _get_today_date_key())

{pyield-0.32.0 → pyield-0.32.2}/pyield/holidays/br_holidays_new.txt

@@ -3,6 +3,111 @@
 # Direct link to the ANBIMA file: https://www.anbima.com.br/feriados/arqs/feriados_nacionais.xls
 # In december 2023, a new holiday was added: "Dia Nacional de Zumbi"
 # Note: dates until 22-12-2023 (inclusive) must use "old_br_holidays.txt" list
+01/01/1990
+26/02/1990
+27/02/1990
+01/05/1990
+14/06/1990
+07/09/1990
+12/10/1990
+02/11/1990
+15/11/1990
+25/12/1990
+01/01/1991
+11/02/1991
+12/02/1991
+29/03/1991
+01/05/1991
+30/05/1991
+15/11/1991
+25/12/1991
+01/01/1992
+02/03/1992
+03/03/1992
+17/04/1992
+21/04/1992
+01/05/1992
+18/06/1992
+07/09/1992
+12/10/1992
+02/11/1992
+25/12/1992
+01/01/1993
+22/02/1993
+23/02/1993
+09/04/1993
+21/04/1993
+10/06/1993
+07/09/1993
+12/10/1993
+02/11/1993
+15/11/1993
+14/02/1994
+15/02/1994
+01/04/1994
+21/04/1994
+02/06/1994
+07/09/1994
+12/10/1994
+02/11/1994
+15/11/1994
+27/02/1995
+28/02/1995
+14/04/1995
+21/04/1995
+01/05/1995
+15/06/1995
+07/09/1995
+12/10/1995
+02/11/1995
+15/11/1995
+25/12/1995
+01/01/1996
+19/02/1996
+20/02/1996
+05/04/1996
+01/05/1996
+06/06/1996
+15/11/1996
+25/12/1996
+01/01/1997
+10/02/1997
+11/02/1997
+28/03/1997
+21/04/1997
+01/05/1997
+29/05/1997
+25/12/1997
+01/01/1998
+23/02/1998
+24/02/1998
+10/04/1998
+21/04/1998
+01/05/1998
+11/06/1998
+07/09/1998
+12/10/1998
+02/11/1998
+25/12/1998
+01/01/1999
+15/02/1999
+16/02/1999
+02/04/1999
+21/04/1999
+03/06/1999
+07/09/1999
+12/10/1999
+02/11/1999
+15/11/1999
+06/03/2000
+07/03/2000
+01/05/2000
+22/06/2000
+07/09/2000
+12/10/2000
+02/11/2000
+15/11/2000
+25/12/2000
 01/01/2001
 26/02/2001
 27/02/2001

pyield-0.32.2/pyield/retry.py

@@ -0,0 +1,154 @@
+"""
+Módulo de retry configurável para chamadas de API e processamento de dados.
+
+Este módulo fornece um decorador `tenacity.retry` pré-configurado (`default_retry`)
+para lidar com erros transitórios comuns ao interagir com APIs web e ao
+processar os dados resultantes (ex: parsing de CSV/JSON).
+"""
+
+import logging
+from urllib.error import HTTPError, URLError
+
+# Dependências de terceiros
+import pandas as pd
+import tenacity
+
+# Importar tipos específicos necessários
+from tenacity import RetryCallState
+
+# --- Configuração do Logger ---
+logger = logging.getLogger(__name__)
+
+# --- Constantes ---
+DEFAULT_TIMEOUT = (2, 10)
+RETRYABLE_NETWORK_ERRORS = (URLError,)
+RETRYABLE_PARSING_ERRORS = (pd.errors.EmptyDataError, pd.errors.ParserError)
+
+
+# --- Funções Auxiliares para Tenacity ---
+
+
+def _log_before_sleep(retry_state: RetryCallState):
+    """
+    Loga uma mensagem ANTES de o Tenacity entrar em espera (sleep) entre tentativas.
+
+    Simplificada para confiar no contrato do Tenacity e usar asserções
+    para verificar o estado esperado.
+    """
+    # 1. Verificar o resultado (outcome)
+    outcome = retry_state.outcome
+    assert outcome is not None, "before_sleep chamada sem 'outcome'"
+    # Adicionado: Garantir que realmente falhou antes de logar como falha
+    assert outcome.failed, "before_sleep chamada para 'outcome' bem-sucedido"
+
+    exception = outcome.exception
+    # Adicionado: Garantir que a exceção existe quando falhou
+    assert exception is not None, "before_sleep chamada sem 'exception' no outcome"
+
+    # 2. Verificar a próxima ação (next_action)
+    next_action = retry_state.next_action
+    assert next_action is not None, "before_sleep chamada sem 'next_action'"
+
+    # 3. Acessar a duração do sono (sleep)
+    # Confiamos que 'next_action' terá '.sleep' neste contexto, pois é antes de dormir.
+    sleep_duration = next_action.sleep
+
+    # Log principal
+    logger.warning(
+        f"Tentativa {retry_state.attempt_number} falhou com "
+        f"{type(exception).__name__}: {exception}. Tentando novamente em "
+        f"{sleep_duration:.2f} segundos..."
+    )
+
+
+def should_retry_exception(retry_state: RetryCallState) -> bool:
+    """Determina se uma exceção capturada justifica uma nova tentativa."""
+    if not retry_state.outcome or not retry_state.outcome.failed:
+        return False
+
+    # Usar o atributo .exception
+    exception = retry_state.outcome.exception
+    assert exception is not None, (
+        "should_retry_exception processando um outcome sem exceção?"
+    )
+
+    attempt_number = retry_state.attempt_number
+    url = getattr(exception, "url", "N/A")
+
+    retry_decision = False
+    log_message = ""
+    log_level = logging.ERROR
+
+    match exception:
+        case HTTPError(code=404):
+            log_message = (
+                f"Tentativa {attempt_number}: Recurso não encontrado (404) em {url}. "
+                f"Não tentará novamente."
+            )
+            retry_decision = False
+            log_level = logging.INFO
+
+        case HTTPError(code=504) if attempt_number == 1:
+            log_message = (
+                f"Tentativa {attempt_number}: Gateway Timeout (504) da API em {url}. "
+                f"Tentará novamente uma vez."
+            )
+            retry_decision = True
+            log_level = logging.WARNING
+
+        case HTTPError(code=504):
+            log_message = (
+                f"Tentativa {attempt_number}: Gateway Timeout (504) persistiu em {url}."
+                f"API parece indisponível. Desistindo."
+            )
+            retry_decision = False
+            log_level = logging.ERROR
+
+        case HTTPError() as http_err:
+            log_message = (
+                f"Tentativa {attempt_number}: Erro HTTP {http_err.code} encontrado "
+                f"para {url}. Pode ser transitório. Tentando novamente."
+            )
+            retry_decision = True
+            log_level = logging.WARNING
+
+        case URLError():
+            log_message = (
+                f"Tentativa {attempt_number}: Erro de rede recuperável "
+                f"({type(exception).__name__}). Tentando novamente."
+            )
+            retry_decision = True
+            log_level = logging.WARNING
+
+        case pd.errors.EmptyDataError() | pd.errors.ParserError():
+            log_message = (
+                f"Tentativa {attempt_number}: Erro de parsing "
+                f"({type(exception).__name__}). Tentando novamente."
+            )
+            retry_decision = True
+            log_level = logging.WARNING
+
+        case _:
+            log_message_exc = (
+                f"Tentativa {attempt_number}: Erro não recuperável/inesperado "
+                f"({type(exception).__name__}). Desistindo."
+            )
+            retry_decision = False
+            log_level = logging.ERROR
+            logger.exception(log_message_exc)
+            log_message = None
+
+    if log_message:
+        logger.log(log_level, log_message)
+
+    return retry_decision
+
+
+# --- Decorador Tenacity Principal ---
+default_retry = tenacity.retry(
+    retry=should_retry_exception,
+    wait=tenacity.wait_exponential(multiplier=1, min=1, max=10),
+    stop=(tenacity.stop_after_attempt(3) | tenacity.stop_after_delay(15)),
+    before_sleep=_log_before_sleep,
+    reraise=True,
+)

{pyield-0.32.0 → pyield-0.32.2}/pyproject.toml

@@ -14,7 +14,7 @@ classifiers = [
     "Topic :: Office/Business :: Financial :: Investment",
 ]
 dependencies = [
-    "pandas[html]>=2.0.0",
+    "pandas[html, parquet]>=2.0.0",
     "numpy>=2.0.0",    
     "requests>=2.31.0",
     "tenacity>=9.0.0",

pyield-0.32.0/pyield/__about__.py

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

pyield-0.32.0/pyield/data_cache.py

@@ -1,184 +0,0 @@
-"""
-Módulo para carregamento e cache de dados financeiros.
-Fornece acesso a dados DI e TPF com atualizações automáticas.
-"""
-
-import logging
-from functools import wraps
-from typing import Any, Dict
-from zoneinfo import ZoneInfo
-
-import pandas as pd
-import requests
-
-from pyield import bday
-
-# Configuração de logging
-logger = logging.getLogger(__name__)
-
-# Configurações
-TIMEZONE_BZ = ZoneInfo("America/Sao_Paulo")
-
-GIT_URL = "https://raw.githubusercontent.com/crdcj/pyield-data/main"
-DI_URL = f"{GIT_URL}/data/b3_di.pkl.gz"
-TPF_URL = f"{GIT_URL}/data/anbima_tpf.pkl.gz"
-
-# Configuração de datasets
-DATASETS_CONFIG = {
-    "di": {"url": f"{DI_URL}", "date_column": "TradeDate"},
-    "tpf": {"url": f"{TPF_URL}", "date_column": "ReferenceDate"},
-}
-
-
-def singleton(cls):
-    """Decorator para implementar o padrão Singleton."""
-    instances = {}
-
-    @wraps(cls)
-    def get_instance(*args, **kwargs):
-        if cls not in instances:
-            instances[cls] = cls(*args, **kwargs)
-        return instances[cls]
-
-    return get_instance
-
-
-@singleton
-class DataCache:
-    """
-    Classe para gerenciar o cache de datasets financeiros.
-    Implementa o padrão Singleton para garantir uma única instância.
-    """
-
-    def __init__(self):
-        """Inicializa o cache de dados vazio."""
-        self._datasets: Dict[str, Dict[str, Any]] = {}
-
-        # Inicializar configurações de datasets
-        for key, config in DATASETS_CONFIG.items():
-            self._datasets[key] = {
-                "url": config["url"],
-                "date_column": config["date_column"],
-                "df": None,
-                "last_date": None,
-            }
-
-    def _should_update_dataset(self, key: str) -> bool:
-        """
-        Verifica se o dataset precisa ser atualizado.
-
-        Args:
-            key: Identificador do dataset
-
-        Returns:
-            True se o dataset precisar ser atualizado, False caso contrário
-        """
-        data_info = self._datasets[key]
-        last_date_in_dataset = data_info["last_date"]
-
-        # Se nunca foi carregado, deve atualizar
-        if last_date_in_dataset is None:
-            return True
-
-        bz_last_bday = bday.last_business_day().date()
-        n_bdays = bday.count(last_date_in_dataset, bz_last_bday)
-
-        # Atualizar se houver mais de 1 dia útil de diferença
-        return n_bdays > 1  # noqa
-
-    def _load_dataset(self, key: str) -> None:
-        """
-        Carrega ou atualiza um dataset.
-
-        Args:
-            key: Identificador do dataset
-
-        Raises:
-            requests.RequestException: Se ocorrer erro ao fazer download dos dados
-            ValueError: Se o formato dos dados for inválido
-        """
-        dataset_info = self._datasets[key]
-
-        try:
-            logger.info(f"Carregando dataset {key} de {dataset_info['url']}")
-            df = pd.read_pickle(dataset_info["url"])
-
-            # Validar se o DataFrame tem a coluna de data esperada
-            date_column = dataset_info["date_column"]
-            if date_column not in df.columns:
-                raise ValueError(
-                    f"Coluna de data '{date_column}' não encontrada no dataset '{key}'"
-                )
-
-            dataset_info["df"] = df
-            dataset_info["last_date"] = df[date_column].max().date()
-
-            logger.info(
-                f"Dataset {key} atualizado. Última data: {dataset_info['last_date']}"
-            )
-
-        except requests.RequestException as e:
-            logger.error(f"Erro ao fazer download do dataset {key}: {str(e)}")
-            raise
-        except Exception as e:
-            logger.error(f"Erro ao processar dataset {key}: {str(e)}")
-            raise
-
-    def get_dataframe(self, key: str) -> pd.DataFrame:
-        """
-        Obtém um DataFrame, carregando-o ou atualizando-o se necessário.
-
-        Args:
-            key: Identificador do dataset
-
-        Returns:
-            DataFrame com os dados solicitados
-
-        Raises:
-            ValueError: Se o dataset não estiver configurado
-            Exception: Se ocorrer erro ao carregar os dados
-        """
-        dataset_info = self._datasets.get(key)
-
-        if dataset_info is None:
-            logger.error(f"Dataset '{key}' não está configurado")
-            raise ValueError(f"Dataset '{key}' não está configurado")
-
-        try:
-            if dataset_info["df"] is None or self._should_update_dataset(key):
-                self._load_dataset(key)
-
-            return dataset_info["df"].copy()
-        except Exception as e:
-            logger.error(f"Erro ao obter dataset {key}: {str(e)}")
-            raise e
-
-
-# Instância única da classe para uso interno da biblioteca
-_data_cache = DataCache()
-
-
-def get_di_dataset() -> pd.DataFrame:
-    """
-    Obtém o dataset de DI (Depósito Interfinanceiro).
-
-    Returns:
-        DataFrame com os dados de DI
-
-    Raises:
-        Exception: Se ocorrer erro ao carregar os dados
-    """
-    return _data_cache.get_dataframe("di")
-
-
-def get_tpf_dataset() -> pd.DataFrame:
-    """
-    Obtém o dataset de TPF (Títulos Públicos Federais).
-
-    Returns:
-        DataFrame com os dados de TPF
-
-    Raises:
-        Exception: Se ocorrer erro ao carregar os dados
-    """
-    return _data_cache.get_dataframe("tpf")

pyield-0.32.0/pyield/retry.py

@@ -1,56 +0,0 @@
-import logging
-import time
-from urllib.error import HTTPError, URLError
-
-import pandas as pd
-import tenacity
-
-logger = logging.getLogger(__name__)
-
-# Default timeout values for HTTP requests (connect_timeout, read_timeout)
-DEFAULT_TIMEOUT = (2, 10)
-
-
-def retry_if_recoverable(exception):
-    """
-    Determine if the exception is worth retrying.
-    """
-    if isinstance(exception, HTTPError):
-        # Don't retry for 404 errors
-        if exception.code == 404:  # noqa
-            logger.info("Resource not found (404), not retrying.")
-            return False
-
-        # Don't retry for 504 Gateway Timeout after first attempt
-        # These often indicate longer-term issues with API
-        if exception.code == 504:  # noqa
-            logger.warning(
-                "Gateway Timeout (504) from API - likely service degradation."
-            )
-            # Check if we've already retried for this 504
-            retry_state = getattr(retry_if_recoverable, "retry_for_504", 0)
-            if retry_state >= 1:
-                logger.error("Multiple 504 errors - BC API appears to be unavailable.")
-                return False
-            # Allow just one retry for 504 with a longer wait
-            retry_if_recoverable.retry_for_504 = retry_state + 1
-            time.sleep(2)  # Immediate wait before retry
-            return True
-
-    # Reset the 504 counter for other types of errors
-    retry_if_recoverable.retry_for_504 = 0
-
-    # Retry for other HTTP errors, URLErrors, and parsing errors
-    return isinstance(
-        exception,
-        (HTTPError, URLError, pd.errors.EmptyDataError, pd.errors.ParserError),
-    )
-
-
-# Custom retry configuration that handles parsing errors
-default_retry = tenacity.retry(
-    retry=tenacity.retry_if_exception(retry_if_recoverable),
-    stop=(tenacity.stop_after_attempt(3) | tenacity.stop_after_delay(15)),
-    wait=tenacity.wait_exponential(multiplier=0.5, min=0.5, max=2),
-    before_sleep=tenacity.before_sleep_log(logger, logging.WARNING),
-)