PYield 0.27.0__tar.gz → 0.27.2__tar.gz

{pyield-0.27.0 → pyield-0.27.2}/PKG-INFO

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

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

{pyield-0.27.0 → pyield-0.27.2}/pyield/__init__.py

@@ -1,3 +1,5 @@
+import logging
+
 from pyield import bday
 from pyield.__about__ import __version__
 from pyield.anbima.ima import ima
@@ -6,6 +8,7 @@ from pyield.anbima.tpf import anbima_tpf_data, anbima_tpf_rates, tpf_pre_maturit
 from pyield.b3_futures import futures
 from pyield.b3_futures.di import DIFutures
 from pyield.bc.auction import auctions
+from pyield.bc.repos import repos
 from pyield.indicators import indicator
 from pyield.interpolator import Interpolator
 from pyield.projections import projection
@@ -18,6 +21,7 @@ __all__ = [
     "anbima_tpf_rates",
     "tpf_pre_maturities",
     "auctions",
+    "repos",
     "bday",
     "DIFutures",
     "forward_rates",
@@ -32,3 +36,7 @@ __all__ = [
     "ntnf",
     "projection",
 ]
+
+
+# Configura o logger do pacote principal com um NullHandler
+logging.getLogger(__name__).addHandler(logging.NullHandler())

{pyield-0.27.0 → pyield-0.27.2}/pyield/anbima/imaq.py

@@ -10,6 +10,10 @@ from bs4 import XMLParsedAsHTMLWarning
 from pyield import date_converter as dc
 from pyield.date_converter import DateScalar
 
+# Configura o logger do módulo
+logger = logging.getLogger(__name__)
+
+
 IMA_URL = "https://www.anbima.com.br/informacoes/ima/ima-quantidade-mercado.asp"
 COLUMN_MAPPING = {
     "Data Referência": "Date",
@@ -42,7 +46,7 @@ def _fetch_url_tables(target_date: pd.Timestamp) -> pd.DataFrame:
     r.raise_for_status()
     r.encoding = "iso-8859-1"
     if "Não há dados disponíveis" in r.text:
-        logging.warning("No data found. Returning empty DataFrame.")
+        logger.warning(f"No data for {target_date_str}. Returning empty DataFrame.")
         return pd.DataFrame()
 
     string_io_buffer = io.StringIO(r.text)
@@ -80,7 +84,7 @@ def _fetch_url_tables(target_date: pd.Timestamp) -> pd.DataFrame:
         anbima_date_str = match.group(1)
         anbima_date = pd.to_datetime(anbima_date_str, format="%d/%m/%Y")
     else:
-        logging.warning("No date found. Returning empty DataFrame.")
+        logger.warning(f"No data for {target_date_str}. Returning empty DataFrame.")
         return pd.DataFrame()
 
     df["Data Referência"] = anbima_date
@@ -133,10 +137,11 @@ def imaq(date: DateScalar) -> pd.DataFrame:
     try:
         date = dc.convert_input_dates(date)
         df = _fetch_url_tables(date)
-        df = _process_df(df)
-        return df
-    except Exception as e:
+        if df.empty:
+            return df
+        return _process_df(df)
+    except Exception:  # Erro inesperado
         date_str = date.strftime("%d/%m/%Y")
-        logging.error(f"Error fetching IMA for {date_str}. Returning empty DataFrame.")
-        logging.error(f"Error message: {e}", exc_info=True)
+        msg = f"Error fetching IMA for {date_str}. Returning empty DataFrame."
+        logger.exception(msg)
         return pd.DataFrame()

{pyield-0.27.0 → pyield-0.27.2}/pyield/bc/auction.py

@@ -141,8 +141,8 @@ def _add_dv01(df: pd.DataFrame) -> pd.DataFrame:
     df_ltn = df_is_accepted.query("BondType == 'LTN'").reset_index(drop=True)
     if not df_ltn.empty:
         df_ltn["Duration"] = df_ltn["BDToMat"] / 252
-        df_ltn["MDuration"] = df_ltn["Duration"] / (1 + df_ltn["AvgRate"])
-        df_ltn["DV01FR"] = 0.0001 * df_ltn["MDuration"] * df_ltn["AvgPrice"]
+        mduration = df_ltn["Duration"] / (1 + df_ltn["AvgRate"])
+        df_ltn["DV01FR"] = 0.0001 * mduration * df_ltn["AvgPrice"]
 
     def compute_f_duration(row):
         return duration_f(row["Date"], row["Maturity"], row["CutRate"])
@@ -151,8 +151,8 @@ def _add_dv01(df: pd.DataFrame) -> pd.DataFrame:
     if not df_ntnf.empty:
         df_ntnf["Duration"] = df_ntnf.apply(compute_f_duration, axis=1)
         df_ntnf["Duration"] = df_ntnf["Duration"].astype("Float64")
-        df_ntnf["MDuration"] = df_ntnf["Duration"] / (1 + df_ntnf["AvgRate"])
-        df_ntnf["DV01FR"] = 0.0001 * df_ntnf["MDuration"] * df_ntnf["AvgPrice"]
+        mduration = df_ntnf["Duration"] / (1 + df_ntnf["AvgRate"])
+        df_ntnf["DV01FR"] = 0.0001 * mduration * df_ntnf["AvgPrice"]
 
     def compute_b_duration(row):
         return duration_b(row["Date"], row["Maturity"], row["CutRate"])
@@ -161,8 +161,8 @@ def _add_dv01(df: pd.DataFrame) -> pd.DataFrame:
     if not df_ntnb.empty:
         df_ntnb["Duration"] = df_ntnb.apply(compute_b_duration, axis=1)
         df_ntnb["Duration"] = df_ntnb["Duration"].astype("Float64")
-        df_ntnb["MDuration"] = df_ntnb["Duration"] / (1 + df_ntnb["AvgRate"])
-        df_ntnb["DV01FR"] = 0.0001 * df_ntnb["MDuration"] * df_ntnb["AvgPrice"]
+        mduration = df_ntnb["Duration"] / (1 + df_ntnb["AvgRate"])
+        df_ntnb["DV01FR"] = 0.0001 * mduration * df_ntnb["AvgPrice"]
 
     df = pd.concat([df_not_accepted, df_lft, df_ltn, df_ntnf, df_ntnb])
 
@@ -181,6 +181,8 @@ def _sort_and_reorder_columns(df: pd.DataFrame) -> pd.DataFrame:
         "Buyer",
         "BondType",
         "Maturity",
+        "BDToMat",
+        "Duration",
         "SelicCode",
         "Value",
         "ValueFR",
@@ -191,14 +193,11 @@ def _sort_and_reorder_columns(df: pd.DataFrame) -> pd.DataFrame:
         "AcceptedQuantity",
         "AcceptedQuantityFR",
         "AcceptedQuantitySR",
+        "DV01FR",
         "AvgPrice",
         "CutPrice",
         "AvgRate",
         "CutRate",
-        "BDToMat",
-        "Duration",
-        "MDuration",
-        "DV01FR",
     ]
 
     primary_sort_keys = ["Date", "AuctionType", "BondType", "Maturity"]
@@ -304,7 +303,6 @@ def auctions(
             - CutRate: Taxa de corte.
             - BDToMat: Dias úteis até o vencimento.
             - Duration: Duration (Duração) do título.
-            - MDuration: Modified Duration (Duração Modificada) do título.
             - DV01FR: Dollar Value of 1 bp change in yield - Primeira Rodada (FR) em R$.
     """
     url = BASE_API_URL

pyield-0.27.2/pyield/bc/repos.py

@@ -0,0 +1,194 @@
+"""
+Documentação da API do BC
+    https://olinda.bcb.gov.br/olinda/servico/leiloes_selic/versao/v1/aplicacao#!/recursos/leiloes_compromissadas
+Exemplo de chamada:
+    https://olinda.bcb.gov.br/olinda/servico/leiloes_selic/versao/v1/odata/leiloes_compromissadas(dataLancamentoInicio=@dataLancamentoInicio,dataLancamentoFim=@dataLancamentoFim,horaInicio=@horaInicio,dataLiquidacao=@dataLiquidacao,dataRetorno=@dataRetorno,publicoPermitidoLeilao=@publicoPermitidoLeilao,nomeTipoOferta=@nomeTipoOferta)?@dataLancamentoInicio='2025-02-13'&@dataLancamentoFim='2025-02-13'&$top=100&$format=text/csv
+"""
+
+import io
+import logging
+
+import pandas as pd
+import requests
+
+from pyield import bday
+from pyield import date_converter as dc
+from pyield.date_converter import DateScalar
+
+"""Dicionário com o mapeamento das colunas da API do BC para o DataFrame final
+Chaves com comentário serão descartadas ao final do processamento
+A ordem das chaves será a ordem das colunas no DataFrame final"""
+COLUMN_MAPPING = {
+    # "id": "ID",
+    "dataMovimento": "Date",
+    "horaInicio": "StartTime",
+    "publicoPermitidoLeilao": "AllowedParticipants",  # ['SomenteDealer', 'TodoMercado']
+    "numeroComunicado": "CommunicationNumber",
+    "nomeTipoOferta": "OfferType",
+    # "ofertante": "Offerer", # Only Banco Central can offer
+    "prazoDiasCorridos": "CDToMat",
+    "dataLiquidacao": "Settlement",
+    "dataRetorno": "Maturity",
+    "volumeAceito": "AcceptedVolume",
+    "taxaCorte": "CutRate",
+    "percentualCorte": "CutPct",
+}
+
+BASE_API_URL = "https://olinda.bcb.gov.br/olinda/servico/leiloes_selic/versao/v1/odata/leiloes_compromissadas(dataLancamentoInicio=@dataLancamentoInicio,dataLancamentoFim=@dataLancamentoFim,horaInicio=@horaInicio,dataLiquidacao=@dataLiquidacao,dataRetorno=@dataRetorno,publicoPermitidoLeilao=@publicoPermitidoLeilao,nomeTipoOferta=@nomeTipoOferta)?"
+
+
+def _load_from_url(url: str) -> pd.DataFrame:
+    response = requests.get(url, timeout=10)
+    response.raise_for_status()
+    return pd.read_csv(
+        io.StringIO(response.text),
+        dtype_backend="numpy_nullable",
+        decimal=",",
+        date_format="%Y-%m-%d",
+        parse_dates=["dataMovimento", "dataLiquidacao", "dataRetorno"],
+    )
+
+
+def _pre_process_df(df: pd.DataFrame) -> pd.DataFrame:
+    # Remover colunas que não serão utilizadas
+    keep_columns = [col for col in COLUMN_MAPPING.keys() if col in df.columns]
+    return df[keep_columns].rename(columns=COLUMN_MAPPING)
+
+
+def _process_df(df: pd.DataFrame) -> pd.DataFrame:
+    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")
+
+    # Remove the percentage sign and round to 6 decimal places (4 decimal places in %)
+    df["CutRate"] = (df["CutRate"] / 100).round(6)
+    # df["BDtoReturn"] = bday.count(df["Date"], df["ReturnDate"])
+    df["BDtoMat"] = bday.count(df["Date"], df["Maturity"])
+    return df
+
+
+def _adjust_null_values(df: pd.DataFrame) -> pd.DataFrame:
+    # Onde não há volume aceito, os valores de corte devem ser nulos
+    is_accepted = df["AcceptedVolume"] != 0
+    df["CutRate"] = df["CutRate"].where(is_accepted, pd.NA)
+    df["CutPct"] = df["CutPct"].where(is_accepted, pd.NA)
+    return df
+
+
+def _sort_and_reorder_columns(df: pd.DataFrame) -> pd.DataFrame:
+    column_sequence = [
+        "Date",
+        "Settlement",
+        "Maturity",
+        "CDToMat",
+        "BDtoMat",
+        "StartTime",
+        "AllowedParticipants",
+        "CommunicationNumber",
+        "OfferType",
+        "AcceptedVolume",
+        "CutRate",
+        "CutPct",
+    ]
+
+    primary_sort_keys = ["Date", "StartTime", "OfferType"]
+    return df[column_sequence].sort_values(by=primary_sort_keys).reset_index(drop=True)
+
+
+def _fetch_df_from_url(url: str) -> pd.DataFrame:
+    try:
+        df = _load_from_url(url)
+        if df.empty:
+            logging.warning("No auction data found for the specified period.")
+            return pd.DataFrame()
+        df = _pre_process_df(df)
+        df = _adjust_null_values(df)
+        df = _process_df(df)
+        df = _sort_and_reorder_columns(df)
+        return df
+    except Exception:
+        logging.exception("Error fetching auction data from BC API.")
+        return pd.DataFrame()
+
+
+def repos(
+    start: DateScalar | None = None,
+    end: DateScalar | None = None,
+) -> pd.DataFrame:
+    """
+    Recupera dados de leilões para um determinado período e tipo de leilão da API do BC.
+
+    **Consultas de Período:**
+    - Para consultar dados de um intervalo, forneça as datas de `start` e `end`.
+      Exemplo: `auctions(start='2024-10-20', end='2024-10-27')`
+    - Se apenas `start` for fornecido, a API do BC retornará dados de leilão a partir
+      da data de `start` **até a data mais recente disponível**.
+      Exemplo: `auctions(start='2024-10-20')`
+    - Se apenas `end` for fornecido, a API do BC retornará dados de leilão **desde a
+      data mais antiga disponível até a data de `end`**.
+      Exemplo: `auctions(end='2024-10-27')`
+
+    **Série Histórica Completa:**
+    - Para recuperar a série histórica completa de leilões (desde 12/11/2012 até o
+      último dia útil), chame a função sem fornecer os parâmetros `start` e `end`.
+      Exemplo: `auctions()`
+
+    Busca dados de leilões da API do BC para as datas de início e fim especificadas,
+    filtrando os resultados diretamente na API pelo tipo de leilão, se especificado.
+    O comportamento da função em relação aos parâmetros `start` e `end` segue o padrão
+    da API do Banco Central:
+    - Se `start` for fornecido e `end` não, a função retorna dados de `start` até o fim.
+    - Se `end` for fornecido e `start` não, a API retorna dados do início até `end`.
+    - Se ambos `start` e `end` forem omitidos, a API retorna a série histórica completa.
+
+    Os dados podem ser filtrados pelo tipo de leilão especificado ("Sell" ou "Buy").
+    Leilões de "Sell" são aqueles em que o Tesouro Nacional vende títulos ao mercado.
+    Leilões de "Buy" são aqueles em que o Tesouro Nacional compra títulos do mercado.
+
+    Args:
+        start (DateScalar, opcional): A data de início para a consulta dos leilões.
+            Se `start` for fornecido e `end` for `None`, a API retornará dados de
+            leilão a partir de `start` até a data mais recente disponível.
+            Se `start` e `end` forem `None`, a série histórica completa será retornada.
+            Padrão é `None`.
+        end (DateScalar, opcional): A data de fim para a consulta de dados de leilão.
+            Se `end` for fornecido e `start` for `None`, a API retornará dados de
+            leilão desde a data mais antiga disponível até a data de `end`.
+            Se `start` e `end` forem `None`, a série histórica completa será retornada.
+            Padrão é `None`.
+
+    Returns:
+        pd.DataFrame: Um DataFrame contendo dados de leilões para o período e tipo
+            especificados. Em caso de erro ao buscar os dados, um DataFrame vazio
+            é retornado e uma mensagem de erro é registrada no log.
+
+    Notes:
+        O DataFrame possui as seguintes colunas:
+            - Date: Data do leilão.
+            - Settlement: Data de liquidação do leilão.
+            - Maturity: Data de retorno do leilão.
+            - CDToMat: Prazo em dias corridos até o vencimento.
+            - BDtoMat: Prazo em dias úteis até o vencimento.
+            - StartTime: Hora de início do leilão.
+            - AllowedParticipants: Participantes permitidos no leilão.
+            - CommunicationNumber: Número do comunicado.
+            - OfferType: Tipo de oferta do leilão.
+            - AcceptedVolume: Volume aceito no leilão (em R$).
+            - CutRate: Taxa de corte do leilão.
+            - CutPct: Percentual de corte do leilão.
+
+    """
+    url = BASE_API_URL
+    if start:
+        start = dc.convert_input_dates(start)
+        start_str = start.strftime("%Y-%m-%d")
+        url += f"@dataLancamentoInicio='{start_str}'"
+
+    if end:
+        end = dc.convert_input_dates(end)
+        end_str = end.strftime("%Y-%m-%d")
+        url += f"&@dataLancamentoFim='{end_str}'"
+
+    url += "&$format=text/csv"  # Adiciona o formato CSV ao final
+
+    return _fetch_df_from_url(url)

{pyield-0.27.0 → pyield-0.27.2}/pyield/indicators.py

@@ -1,6 +1,7 @@
+import io
 import logging
 import time
-from typing import Literal
+from typing import Callable, Literal
 
 import pandas as pd
 import requests
@@ -9,8 +10,11 @@ from requests.exceptions import RequestException
 from pyield import date_converter as dc
 from pyield.date_converter import DateScalar
 
+logger = logging.getLogger(__name__)
+
+# Timeout para as requisições HTTP (conexão e leitura)
 TIMEOUT = (5, 20)
-MAX_ATTEMPTS = 5
+MAX_ATTEMPTS = 10
 
 
 def indicator(
@@ -91,20 +95,15 @@ def ipca_monthly_rate(reference_date: pd.Timestamp) -> float:
     # Construct the API URL using the formatted date
     api_url = f"https://servicodados.ibge.gov.br/api/v3/agregados/6691/periodos/{ipca_date}/variaveis/63?localidades=N1[all]"
 
-    # Send a GET request to the API
-    response = requests.get(api_url, timeout=TIMEOUT)
-
-    # Raises HTTPError, if one occurred
-    response.raise_for_status()
-
-    # Parse the JSON response
-    data = response.json()
+    def process_ipca_response(data):
+        if not data:
+            msg = f"No data available for IPCA Monthly Rate on {reference_date}"
+            logger.warning(msg)
+            return float("nan")
+        ipca_str = data[0]["resultados"][0]["series"][0]["serie"][ipca_date]
+        return round(float(ipca_str) / 100, 4)
 
-    if not data:
-        raise ValueError("No data available for the specified date")
-    # Extract and return the IPCA monthly growth rate if data is available
-    ipca_str = data[0]["resultados"][0]["series"][0]["serie"][ipca_date]
-    return round(float(ipca_str) / 100, 4)
+    return _fetch_with_retry(api_url, "IPCA Monthly Rate", process_ipca_response, True)
 
 
 def _selic_target(reference_date: pd.Timestamp) -> float:
@@ -122,31 +121,21 @@ def _selic_target(reference_date: pd.Timestamp) -> float:
     """
     # https://api.bcb.gov.br/dados/serie/bcdata.sgs.432/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
     selic_date = reference_date.strftime("%d/%m/%Y")
-    api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.432/dados?formato=json&dataInicial={selic_date}&dataFinal={selic_date}"
-
-    attempt = 0
-    while attempt < MAX_ATTEMPTS:
-        try:
-            response = requests.get(api_url, timeout=TIMEOUT)
-            response.raise_for_status()  # Raise an error for bad HTTP response
-
-            # Try parsing JSON, raises an error if response is not valid JSON
-            data = response.json()
-
-            # Access the value directly, any issue will raise an exception
-            value = data[0]["valor"]
-            return round(float(value) / 100, 4)
-
-        except (RequestException, KeyError, IndexError, ValueError) as e:
-            msg = f"Error fetching SELIC Target rate (attempt {attempt + 1}): {e}"
-            logging.error(msg)
+    api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.432/dados?formato=csv&dataInicial={selic_date}&dataFinal={selic_date}"
 
-        # Increment attempt count and add backoff delay
-        attempt += 1
-        time.sleep(1.5**attempt)  # Exponential backoff: 1.5, 2.3, 3.9, 5.1, 7.6 seconds
+    def process_selic_target_response(data):
+        csv_data = io.StringIO(data)
+        df = pd.read_csv(csv_data, sep=";", decimal=",")
+        if df.empty or "valor" not in df.columns:
+            msg = f"No data available for SELIC Target rate on {reference_date}"
+            logger.warning(msg)
+            return float("nan")
+        value = float(df["valor"].iloc[0] / 100)  # SELIC Target rate
+        return round(float(value), 4)
 
-    # After all retries, raise an error
-    raise ValueError("Failed to fetch SELIC Target rate after maximum attempts")
+    return _fetch_with_retry(
+        api_url, "SELIC Target", process_selic_target_response, False
+    )
 
 
 def _selic_over(reference_date: pd.Timestamp) -> float:
@@ -166,99 +155,122 @@ def _selic_over(reference_date: pd.Timestamp) -> float:
 
     formatted_date = reference_date.strftime("%d/%m/%Y")
     # https://api.bcb.gov.br/dados/serie/bcdata.sgs.1178/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
-    api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.1178/dados?formato=json&dataInicial={formatted_date}&dataFinal={formatted_date}"
+    api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.1178/dados?formato=csv&dataInicial={formatted_date}&dataFinal={formatted_date}"
 
-    attempt = 0
+    def process_selic_over_response(data):
+        csv_data = io.StringIO(data)
+        df = pd.read_csv(csv_data, sep=";", decimal=",")
+        if df.empty or "valor" not in df.columns:
+            msg = f"No data available for SELIC Over rate on {reference_date}"
+            logger.warning(msg)
+            return float("nan")
+        value = float(df["valor"].iloc[0] / 100)  # SELIC Over daily rate
+        return round(value, 4)
 
-    while attempt < MAX_ATTEMPTS:
-        try:
-            response = requests.get(api_url, timeout=TIMEOUT)
-            response.raise_for_status()  # Handle 4xx/5xx HTTP errors
+    return _fetch_with_retry(api_url, "SELIC Over", process_selic_over_response, False)
 
-            # Try parsing JSON, raises an error if response is not valid JSON
-            data = response.json()
 
-            # Access the value directly, any issue will raise an exception
-            value = data[0]["valor"]
-            return round(float(value) / 100, 4)
+def _di(reference_date: pd.Timestamp) -> float:
+    # https://api.bcb.gov.br/dados/serie/bcdata.sgs.11/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
+    di_date = reference_date.strftime("%d/%m/%Y")
+    api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.11/dados?formato=csv&dataInicial={di_date}&dataFinal={di_date}"
 
-        except (RequestException, KeyError, IndexError, ValueError) as e:
-            msg = f"Error fetching SELIC Over rate (attempt {attempt + 1}): {e}"
-            logging.error(msg)
+    def process_di_response(data):
+        csv_data = io.StringIO(data)
+        df = pd.read_csv(csv_data, sep=";", decimal=",")
+        if df.empty or "valor" not in df.columns:
+            logger.warning(f"No data available for DI rate on {reference_date}")
+            return float("nan")
+        value = float(df["valor"].iloc[0] / 100)  # DI daily rate
+        return round((1 + value) ** 252 - 1, 4)  # Annualize the daily rate
 
-        # Increment attempt count and add backoff delay
-        attempt += 1
-        time.sleep(1.5**attempt)  # Exponential backoff: 1.5, 2.3, 3.9, 5.1, 7.6 seconds
+    return _fetch_with_retry(api_url, "DI Over", process_di_response, False)
 
-    # After all retries, raise an error
-    raise ValueError("Failed to fetch SELIC Over rate after maximum attempts")
 
+def _vna_lft(reference_date: pd.Timestamp) -> float:
+    # url example: https://www3.bcb.gov.br/novoselic/rest/arquivosDiarios/pub/download/3/20240418APC238
+    url_base = "https://www3.bcb.gov.br/novoselic/rest/arquivosDiarios/pub/download/3/"
+    url_file = f"{reference_date.strftime('%Y%m%d')}APC238"
+    url_vna = url_base + url_file
 
-def _di(reference_date: pd.Timestamp) -> float:
-    # https://api.bcb.gov.br/dados/serie/bcdata.sgs.11/dados?formato=json&dataInicial=12/04/2024&dataFinal=12/04/2024
-    di_date = reference_date.strftime("%d/%m/%Y")
-    api_url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.11/dados?formato=json&dataInicial={di_date}&dataFinal={di_date}"
-    response = requests.get(api_url, timeout=TIMEOUT)
-    response.raise_for_status()
+    def _process_vna_response(text: str) -> float:
+        # Finding the part that contains the table
+        start_of_table = text.find("EMISSAO")
+        end_of_table = text.find("99999999*")
 
-    if di_date not in response.text:
-        return float("nan")
-    data = response.json()
-    value = float(data[0]["valor"]) / 100  # DI daily rate
-    # Annualize the daily rate
-    return round((1 + value) ** 252 - 1, 4)
+        # Extracting the table
+        table_text = text[start_of_table:end_of_table].strip()
+        table_lines = table_text.splitlines()
 
+        # Remove empty lines
+        table_lines = [line.strip() for line in table_lines if line.strip()]
 
-def _extract_vna_value(text: str) -> float:
-    # Finding the part that contains the table
-    start_of_table = text.find("EMISSAO")
-    end_of_table = text.find("99999999*")
+        # Remove first line
+        body_lines = table_lines[1:]
 
-    # Extracting the table
-    table_text = text[start_of_table:end_of_table].strip()
-    table_lines = table_text.splitlines()
+        vnas = []
+        for line in body_lines:
+            vna_str = line.split()[-1].replace(",", ".")
+            vnas.append(float(vna_str))
 
-    # Remove empty lines
-    table_lines = [line.strip() for line in table_lines if line.strip()]
+        # Raise error if all values are not the same
+        vna_value = vnas[0]
+        if any(vna_value != vna for vna in vnas):
+            bcb_url = "https://www.bcb.gov.br/estabilidadefinanceira/selicbaixar"
+            msg = f"VNA values are not the same. Please check data at {bcb_url}"
+            raise ValueError(msg)
 
-    # Remove first line
-    body_lines = table_lines[1:]
+        return vna_value
 
-    vnas = []
-    for line in body_lines:
-        vna_str = line.split()[-1].replace(",", ".")
-        vnas.append(float(vna_str))
+    return _fetch_with_retry(url_vna, "VNA LFT", _process_vna_response, False)
 
-    # Raise error if all values are not the same
-    vna_value = vnas[0]
-    if any(vna_value != vna for vna in vnas):
-        bcb_url = "https://www.bcb.gov.br/estabilidadefinanceira/selicbaixar"
-        raise ValueError(f"VNA values are not the same. Please check data at {bcb_url}")
 
-    return vna_value
+def _fetch_with_retry(
+    api_url: str,
+    error_message: str,
+    process_response: Callable[[requests.Response], float],
+    use_json: bool = True,
+) -> float:
+    """
+    Função genérica para fazer requisições HTTP com retentativas e tratamento de erro.
 
+    Args:
+        api_url (str): URL da API a ser chamada.
+        error_message (str): Mensagem de erro específica para a função que está usando.
+        process_response (Callable[[str], float]): Função para processar os dados da
+            resposta (JSON decodificado ou texto, dependendo de 'use_json').
+            Deve retornar um float.
+        use_json (bool): Se True, tenta decodificar a resposta como JSON antes de passar
+            para `process_response`. Se False, passa a resposta como texto.
 
-def _vna_lft(reference_date: pd.Timestamp) -> float:
-    # url example: https://www3.bcb.gov.br/novoselic/rest/arquivosDiarios/pub/download/3/20240418APC238
-    url_base = "https://www3.bcb.gov.br/novoselic/rest/arquivosDiarios/pub/download/3/"
-    url_file = f"{reference_date.strftime('%Y%m%d')}APC238"
-    url_vna = url_base + url_file
-    session = requests.Session()
+    Returns:
+        float: O resultado do processamento da resposta.
 
+    Raises:
+        ValueError: Se a requisição falhar após o número máximo de tentativas.
+    """
     attempt = 0
     while attempt < MAX_ATTEMPTS:
         try:
-            response = session.get(url_vna, timeout=TIMEOUT)
-            response.raise_for_status()
-            return _extract_vna_value(response.text)
+            response = requests.get(api_url, timeout=TIMEOUT)
+            response.raise_for_status()  # Levanta uma exceção para códigos de erro HTTP
+
+            if use_json:
+                data = response.json()
+            else:
+                data = response.text
+
+            return process_response(data)
+
+        except RequestException as e:
+            msg = f"Erro ao buscar {error_message} (tentativa {attempt + 1}): {e}"
+            logger.error(msg)
 
-        except (RequestException, KeyError, IndexError, ValueError) as e:
-            msg = f"Error fetching SELIC Over rate (attempt {attempt + 1}): {e}"
-            logging.error(msg)
+        except Exception as unhandled_error:  # Outros erros - LÓGICA INESPERADA!
+            msg = f"Erro INESPERADO ao buscar {error_message}: {unhandled_error}"
+            logger.exception(msg)  # Loga stack trace completo para debug
 
-        # Increment attempt count and add backoff delay
         attempt += 1
-        time.sleep(1.5**attempt)  # Exponential backoff: 1.5, 2.3, 3.9, 5.1, 7.6 seconds
+        time.sleep(1.2**attempt)  # Backoff exponencial
 
-    # After all retries, raise an error
-    raise ValueError("Failed to fetch VNA LFT value after maximum attempts")
+    raise ValueError(f"Falha ao buscar {error_message} após {MAX_ATTEMPTS} tentativas")

pyield-0.27.0/pyield/__about__.py

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