PYield 0.46.2__tar.gz → 0.46.4__tar.gz

{pyield-0.46.2 → pyield-0.46.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyield
-Version: 0.46.2
+Version: 0.46.4
 Summary: A Python library for analysis of fixed income instruments in Brazil
 Project-URL: Homepage, https://github.com/crdcj/PYield
 Project-URL: Documentation, https://crdcj.github.io/PYield
@@ -71,10 +71,10 @@ yd.bday.offset("29-12-2023", 1)            # -> datetime.date(2024, 1, 2)
 
 # Curva de DI Futuro
 df = yd.futures("31-05-2024", "DI1")
-# Columns: TradeDate, TickerSymbol, ExpirationDate, BDaysToExp, SettlementRate, ...
+# Columns: data_referencia, codigo_negociacao, data_vencimento, dias_uteis, taxa_ajuste, ...
 
 # Interpolação de taxas (flat forward, convenção 252 dias úteis/ano)
-interp = yd.Interpolator("flat_forward", df["BDaysToExp"], df["SettlementRate"])
+interp = yd.Interpolator("flat_forward", df["dias_uteis"], df["taxa_ajuste"])
 interp(45)       # -> 0.04833...
 interp([30, 60]) # -> pl.Series with interpolated rates
 
@@ -200,7 +200,7 @@ ntnb.quotation("31-05-2024", "15-08-2060", 0.061878)  # -> 99.5341
 
 # Spreads de DI (bps=True multiplica por 10.000)
 ntnf.di_spreads("30-05-2025", bps=True)
-# -> DataFrame: BondType, MaturityDate, DISpread
+# -> DataFrame: titulo, data_vencimento, spread_di
 ```
 
 ## Dados de Futuros

{pyield-0.46.2 → pyield-0.46.4}/README.md

@@ -27,10 +27,10 @@ yd.bday.offset("29-12-2023", 1)            # -> datetime.date(2024, 1, 2)
 
 # Curva de DI Futuro
 df = yd.futures("31-05-2024", "DI1")
-# Columns: TradeDate, TickerSymbol, ExpirationDate, BDaysToExp, SettlementRate, ...
+# Columns: data_referencia, codigo_negociacao, data_vencimento, dias_uteis, taxa_ajuste, ...
 
 # Interpolação de taxas (flat forward, convenção 252 dias úteis/ano)
-interp = yd.Interpolator("flat_forward", df["BDaysToExp"], df["SettlementRate"])
+interp = yd.Interpolator("flat_forward", df["dias_uteis"], df["taxa_ajuste"])
 interp(45)       # -> 0.04833...
 interp([30, 60]) # -> pl.Series with interpolated rates
 
@@ -156,7 +156,7 @@ ntnb.quotation("31-05-2024", "15-08-2060", 0.061878)  # -> 99.5341
 
 # Spreads de DI (bps=True multiplica por 10.000)
 ntnf.di_spreads("30-05-2025", bps=True)
-# -> DataFrame: BondType, MaturityDate, DISpread
+# -> DataFrame: titulo, data_vencimento, spread_di
 ```
 
 ## Dados de Futuros

pyield-0.46.4/pyield/__about__.py

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

{pyield-0.46.2 → pyield-0.46.4}/pyield/_internal/data_cache.py

@@ -16,8 +16,8 @@ registro = logging.getLogger(__name__)
 
 # Estrutura interna única — usuário não vê isso
 class _Dataset(Enum):
-    TPF = ("anbima_tpf.parquet", "ReferenceDate", "TPF (ANBIMA)")
-    PR = ("b3_price_report.parquet", "TradeDate", "Price Report (B3)")
+    TPF = ("anbima_tpf.parquet", "data_referencia", "TPF (ANBIMA)")
+    FUTURES = ("b3_futures.parquet", "data_referencia", "Futures (B3)")
 
     def __init__(self, nome_arquivo: str, coluna_data: str, descricao: str):
         self.nome_arquivo = nome_arquivo
@@ -25,7 +25,7 @@ class _Dataset(Enum):
         self.descricao = descricao
 
 
-type IdDataset = Literal["tpf", "pr"]
+type IdDataset = Literal["tpf", "futures"]
 
 
 def _obter_chave_data_hoje() -> str:
@@ -37,7 +37,7 @@ def _validar_id_dataset(id_dataset: str) -> _Dataset:
     try:
         return _Dataset[dataset_normalizado.upper()]
     except KeyError as e:
-        msg = f"id_dataset inválido: '{id_dataset}'. Valores aceitos: 'tpf', 'pr'."
+        msg = f"id_dataset inválido: '{id_dataset}'. Valores aceitos: 'tpf', 'futures'."
         raise ValueError(msg) from e
 
 
@@ -81,7 +81,7 @@ def obter_dataset_cacheado(id_dataset: IdDataset) -> pl.DataFrame:
     Obtém um dataset pelo ID. Cache expira diariamente.
 
     Args:
-        id_dataset: "tpf" ou "pr"
+        id_dataset: "tpf" ou "futures"
     """
     df = _obter_dataset_com_ttl(id_dataset.lower(), _obter_chave_data_hoje())
     return df.clone()

pyield-0.46.4/pyield/anbima/tpf.py

@@ -0,0 +1,293 @@
+"""Dados do mercado secundário de Títulos Públicos Federais (TPF) da ANBIMA.
+
+Exemplo de URL:
+    https://www.anbima.com.br/informacoes/merc-sec/arqs/ms240614.txt
+
+Exemplo de dado bruto (CSV separado por @, encoding latin1):
+    ANBIMA - Associação Brasileira das Entidades dos Mercados Financeiro e de Capitais
+
+    Titulo@Data Referencia@Codigo SELIC@Data Base/Emissao@Data Vencimento@Tx. Compra@Tx. Venda@Tx. Indicativas@PU@Desvio padrao@Interv. Ind. Inf. (D0)@Interv. Ind. Sup. (D0)@Interv. Ind. Inf. (D+1)@Interv. Ind. Sup. (D+1)@Criterio
+    LTN@20250924@100000@20230707@20251001@14,9483@14,9263@14,9375@997,241543@0,00433039162894@14,7341@15,2612@14,7316@15,2689@Calculado
+    LTN@20250924@100000@20200206@20260101@14,7741@14,7485@14,7616@963,001853@0,00729826731971@14,7008@14,9986@14,7021@14,9975@Calculado
+"""  # noqa: E501
+
+import datetime as dt
+import logging
+import socket
+from typing import Literal
+
+import polars as pl
+import requests
+
+from pyield import bday
+from pyield._internal.br_numbers import float_br, taxa_br
+from pyield._internal.converters import converter_datas, data_referencia_valida
+from pyield._internal.data_cache import obter_dataset_cacheado
+from pyield._internal.retry import retry_padrao
+from pyield._internal.types import DateLike
+
+BOND_TYPES = Literal["LFT", "NTN-B", "NTN-C", "LTN", "NTN-F", "PRE"]
+
+ANBIMA_URL = "https://www.anbima.com.br/informacoes/merc-sec/arqs"
+ANBIMA_RTM_HOSTNAME = "www.anbima.associados.rtm"
+ANBIMA_RTM_URL = f"http://{ANBIMA_RTM_HOSTNAME}/merc_sec/arqs"
+
+# Antes de 13/05/2014 o arquivo era zipado e o endpoint terminava com ".exe"
+DATA_MUDANCA_FORMATO = dt.date(2014, 5, 13)
+
+DIAS_RETENCAO_PUBLICA = 5
+
+# Colunas selecionadas pela função pública tpf()
+COLUNAS_TPF = (
+    "titulo",
+    "data_referencia",
+    "codigo_selic",
+    "data_base",
+    "data_vencimento",
+    "pu",
+    "taxa_compra",
+    "taxa_venda",
+    "taxa_indicativa",
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _mapear_tipo_titulo(tipo_titulo: str) -> list[str]:
+    tipo_titulo = tipo_titulo.upper()
+    mapa_titulos = {
+        "PRE": ["LTN", "NTN-F"],
+        "NTNB": ["NTN-B"],
+        "NTNC": ["NTN-C"],
+        "NTNF": ["NTN-F"],
+    }
+    return mapa_titulos.get(tipo_titulo, [tipo_titulo])
+
+
+def _montar_nome_arquivo(data: dt.date) -> str:
+    data_url = data.strftime("%y%m%d")
+    if data < DATA_MUDANCA_FORMATO:
+        nome_arquivo = f"ms{data_url}.exe"
+    else:
+        nome_arquivo = f"ms{data_url}.txt"
+    return nome_arquivo
+
+
+def _montar_url_arquivo(data: dt.date) -> str:
+    ultimo_dia_util = bday.last_business_day()
+    qtd_dias_uteis = bday.count(data, ultimo_dia_util)
+    if qtd_dias_uteis > DIAS_RETENCAO_PUBLICA:
+        # Para datas com mais de 5 dias úteis, apenas os dados da RTM estão disponíveis
+        logger.info("Tentando buscar dados RTM para %s", data.strftime("%d/%m/%Y"))
+        url_arquivo = f"{ANBIMA_RTM_URL}/{_montar_nome_arquivo(data)}"
+    else:
+        url_arquivo = f"{ANBIMA_URL}/{_montar_nome_arquivo(data)}"
+    return url_arquivo
+
+
+@retry_padrao
+def _obter_csv(data: dt.date) -> bytes:
+    url_arquivo = _montar_url_arquivo(data)
+    resposta = requests.get(url_arquivo, timeout=10)
+    resposta.raise_for_status()
+    return resposta.content
+
+
+def _parsear_df(csv_bytes: bytes) -> pl.DataFrame:
+    """Converte bytes brutos do CSV da ANBIMA em DataFrame (tudo string)."""
+    return pl.read_csv(
+        source=csv_bytes,
+        skip_lines=2,
+        separator="@",
+        null_values=["--"],
+        infer_schema=False,
+        encoding="latin1",
+    )
+
+
+def _processar_df(df: pl.DataFrame) -> pl.DataFrame:
+    """Renomeia, converte tipos e define a ordem das colunas."""
+    return df.select(
+        titulo=pl.col("Titulo"),
+        data_referencia=pl.col("Data Referencia").str.to_date("%Y%m%d"),
+        codigo_selic=pl.col("Codigo SELIC").cast(pl.Int64),
+        data_base=pl.col("Data Base/Emissao").str.to_date("%Y%m%d"),
+        data_vencimento=pl.col("Data Vencimento").str.to_date("%Y%m%d"),
+        taxa_compra=taxa_br("Tx. Compra"),
+        taxa_venda=taxa_br("Tx. Venda"),
+        taxa_indicativa=taxa_br("Tx. Indicativas"),
+        pu=float_br("PU"),
+        desvio_padrao=float_br("Desvio padrao"),
+        taxa_intervalo_inf_d0=taxa_br("Interv. Ind. Inf. (D0)"),
+        taxa_intervalo_sup_d0=taxa_br("Interv. Ind. Sup. (D0)"),
+        taxa_intervalo_inf_d1=taxa_br("Interv. Ind. Inf. (D+1)"),
+        taxa_intervalo_sup_d1=taxa_br("Interv. Ind. Sup. (D+1)"),
+        criterio=pl.col("Criterio"),
+    )
+
+
+def _buscar_dados_tpf(data: dt.date) -> pl.DataFrame:
+    """Busca e processa dados do mercado secundário de TPF na fonte ANBIMA.
+
+    Args:
+        data: Data de referência.
+
+    Returns:
+        DataFrame processado ou DataFrame vazio se indisponível.
+    """
+    url_arquivo = _montar_url_arquivo(data)
+
+    # Fail-fast: se a URL é RTM e o host não resolve, não adianta tentar
+    if ANBIMA_RTM_URL in url_arquivo:
+        try:
+            socket.gethostbyname(ANBIMA_RTM_HOSTNAME)
+        except socket.gaierror:
+            data_str = data.strftime("%d/%m/%Y")
+            logger.warning(
+                f"Não foi possível resolver o host da RTM para {data_str}. "
+                "Dados históricos exigem acesso à rede RTM."
+            )
+            return pl.DataFrame()
+
+    csv_bytes = _obter_csv(data)
+    if not csv_bytes.strip():
+        return pl.DataFrame()
+
+    df = _parsear_df(csv_bytes)
+    return _processar_df(df)
+
+
+def tpf(
+    date: DateLike,
+    bond_type: BOND_TYPES | None = None,
+) -> pl.DataFrame:
+    """Recupera os dados do mercado secundário de TPF da ANBIMA.
+
+    Esta função busca taxas indicativas e outros dados de títulos públicos
+    brasileiros. Primeiro consulta o cache local; se não houver dados,
+    busca diretamente na fonte (ANBIMA).
+
+    Args:
+        date (DateLike): A data de referência para os dados (ex: '2024-06-14').
+        bond_type (str, optional): Filtra por tipo de título. Aceita os tipos
+            individuais ('LTN', 'NTN-F', 'NTN-B', 'NTN-C', 'LFT') ou 'PRE'
+            como atalho para prefixados ('LTN' e 'NTN-F').
+
+    Returns:
+        pl.DataFrame: Um DataFrame contendo os dados solicitados.
+            Retorna um DataFrame vazio se não houver dados para a data especificada (ex:
+            finais de semana, feriados ou datas futuras).
+
+    Examples:
+        >>> from pyield import anbima
+        >>> df = anbima.tpf(date="06-02-2026")
+
+    Output Columns:
+        * titulo (String): tipo do título público (ex: 'LTN', 'NTN-B').
+        * data_referencia (Date): data de referência dos dados.
+        * codigo_selic (Int64): código do título no SELIC.
+        * data_base (Date): data base ou de emissão do título.
+        * data_vencimento (Date): data de vencimento do título.
+        * pu (Float64): preço unitário (PU) para liquidação em D0.
+        * taxa_compra (Float64): taxa de compra em D0 (decimal).
+        * taxa_venda (Float64): taxa de venda em D0 (decimal).
+        * taxa_indicativa (Float64): taxa indicativa em D0 (decimal).
+
+    Notes:
+        A fonte dos dados segue a seguinte hierarquia:
+
+        1.  **Cache Local:** Fornece acesso rápido a dados históricos
+            desde 01/01/2020.
+        2.  **Fonte ANBIMA (fallback):** Se a data não estiver no cache,
+            busca automaticamente na fonte. Para datas recentes (até 5 dias
+            úteis), usa o site público. Para datas mais antigas, requer
+            acesso à rede RTM.
+
+        Para obter o dado completo direto da fonte (todas as colunas),
+        use :func:`fetch_tpf`.
+    """
+    date = converter_datas(date)
+
+    if not data_referencia_valida(date):
+        return pl.DataFrame()
+
+    # Cache primeiro; se não tiver, busca na fonte
+    df = obter_dataset_cacheado("tpf")
+    if not df.is_empty():
+        df = df.filter(pl.col("data_referencia") == date)
+    if df.is_empty():
+        df = _buscar_dados_tpf(date)
+    if df.is_empty():
+        return pl.DataFrame()
+
+    df = df.select(col for col in COLUNAS_TPF if col in df.columns)
+
+    if bond_type:
+        tipos_titulo = _mapear_tipo_titulo(bond_type)
+        df = df.filter(pl.col("titulo").is_in(tipos_titulo))
+
+    return df.sort("data_referencia", "titulo", "data_vencimento")
+
+
+def fetch_tpf(
+    date: DateLike,
+) -> pl.DataFrame:
+    """Busca os dados do mercado secundário de TPF direto da fonte ANBIMA.
+
+    Retorna todas as colunas publicadas pela ANBIMA, sem cache e sem
+    filtro de colunas. Indicado para uso em jobs e pipelines de dados.
+
+    Args:
+        date (DateLike): Data de referência (ex: '2024-06-14').
+
+    Returns:
+        pl.DataFrame: DataFrame com todas as colunas da ANBIMA.
+            Retorna DataFrame vazio se não houver dados.
+    """
+    date = converter_datas(date)
+
+    if not data_referencia_valida(date):
+        return pl.DataFrame()
+
+    df = _buscar_dados_tpf(date)
+    if df.is_empty():
+        return pl.DataFrame()
+
+    return df.sort("data_referencia", "titulo", "data_vencimento")
+
+
+def tpf_maturities(
+    date: DateLike,
+    bond_type: BOND_TYPES,
+) -> pl.Series:
+    """Recupera os vencimentos existentes para um tipo de título na data especificada.
+
+    Args:
+        date (DateLike): A data de referência para os vencimentos.
+        bond_type (BOND_TYPES): O tipo de título para filtrar (ex: 'PRE' para 'LTN'
+            e 'NTN-F', ou especifique 'LTN' ou 'NTN-F' diretamente).
+
+    Returns:
+        pl.Series: Uma Series contendo as datas de vencimento únicas para o(s)
+            tipo(s) de título especificado(s).
+
+    Examples:
+        >>> from pyield import anbima
+        >>> anbima.tpf_maturities(date="22-08-2025", bond_type="PRE")
+        shape: (18,)
+        Series: 'data_vencimento' [date]
+        [
+            2025-10-01
+            2026-01-01
+            2026-04-01
+            2026-07-01
+            2026-10-01
+            …
+            2030-01-01
+            2031-01-01
+            2032-01-01
+            2033-01-01
+            2035-01-01
+        ]
+    """
+    return tpf(date, bond_type)["data_vencimento"].unique().sort()

{pyield-0.46.2 → pyield-0.46.4}/pyield/b3/_validar_pregao.py

@@ -2,6 +2,10 @@ import datetime as dt
 
 from pyield import bday, clock
 
+# Pregão abre às 9:00, porém os dados intraday têm atraso de 15 minutos.
+# Esperar 1 minuto adicional para garantir que estejam disponíveis (9:16h).
+HORA_INICIO_INTRADAY = dt.time(9, 16)
+
 
 def data_negociacao_valida(data_negociacao: dt.date) -> bool:
     """Valida se a data de referência é utilizável para consulta.
@@ -26,3 +30,15 @@ def data_negociacao_valida(data_negociacao: dt.date) -> bool:
         return False
 
     return True
+
+
+def intraday_disponivel() -> bool:
+    """Verifica se dados intraday estão disponíveis agora.
+
+    Critérios:
+    - Hoje deve ser um dia de pregão válido.
+    - O horário atual deve ser após o início dos dados intraday (9:16h).
+    """
+    if not data_negociacao_valida(clock.today()):
+        return False
+    return clock.now().time() >= HORA_INICIO_INTRADAY

{pyield-0.46.2 → pyield-0.46.4}/pyield/b3/di1.py

@@ -36,12 +36,19 @@ def data(
     Examples:
         >>> from pyield import di1
         >>> df = di1.data(dates="16-10-2024", month_start=True)
-        >>> {"TradeDate", "TickerSymbol", "ExpirationDate", "SettlementRate"}.issubset(
-        ...     set(df.columns)
+        >>> df.head(3).select(
+        ...     "codigo_negociacao", "data_vencimento", "dias_uteis", "taxa_ajuste"
         ... )
-        True
-        >>> df.shape[0] > 0
-        True
+        shape: (3, 4)
+        ┌───────────────────┬─────────────────┬────────────┬─────────────┐
+        │ codigo_negociacao ┆ data_vencimento ┆ dias_uteis ┆ taxa_ajuste │
+        │ ---               ┆ ---             ┆ ---        ┆ ---         │
+        │ str               ┆ date            ┆ i64        ┆ f64         │
+        ╞═══════════════════╪═════════════════╪════════════╪═════════════╡
+        │ DI1X24            ┆ 2024-11-01      ┆ 12         ┆ 0.10653     │
+        │ DI1Z24            ┆ 2024-12-01      ┆ 31         ┆ 0.1091      │
+        │ DI1F25            ┆ 2025-01-01      ┆ 52         ┆ 0.11164     │
+        └───────────────────┴─────────────────┴────────────┴─────────────┘
 
     """
     if any_is_empty(dates):
@@ -62,36 +69,32 @@ def data(
     if pre_filter:
         df_tpf = (
             obter_dataset_cacheado("tpf")
-            .filter(pl.col("BondType").is_in(["LTN", "NTN-F"]))
-            .unique(subset=["MaturityDate", "ReferenceDate"])
+            .filter(pl.col("titulo").is_in(["LTN", "NTN-F"]))
+            .unique(subset=["data_vencimento", "data_referencia"])
             .select(
-                TradeDate_tpf=pl.col("ReferenceDate"),
-                ExpirationDate=bday.offset_expr("MaturityDate", 0),
+                data_ref_tpf=pl.col("data_referencia"),
+                data_vencimento=bday.offset_expr("data_vencimento", 0),
             )
-            .sort("TradeDate_tpf", "ExpirationDate")
+            .sort("data_ref_tpf", "data_vencimento")
         )
 
-        # Ajustar as datas de vencimento para dias úteis, como está no DI1
-        # exp_dates = bday.offset(df_tpf["ExpirationDate"], 0)
-        # df_tpf = df_tpf.with_columns(ExpirationDate=exp_dates)
-
-        # Mapear cada TradeDate do DI para a data TPF mais próxima
+        # Mapear cada data_referencia do DI para a data TPF mais próxima
         df = df.join_asof(
-            df_tpf.select("TradeDate_tpf").unique().sort("TradeDate_tpf"),
-            left_on="TradeDate",
-            right_on="TradeDate_tpf",
+            df_tpf.select("data_ref_tpf").unique().sort("data_ref_tpf"),
+            left_on="data_referencia",
+            right_on="data_ref_tpf",
             strategy="backward",
         )
 
         # Filtrar apenas vencimentos que existem no TPF
-        df = df.join(df_tpf, on=["TradeDate_tpf", "ExpirationDate"], how="inner").drop(
-            "TradeDate_tpf"
+        df = df.join(df_tpf, on=["data_ref_tpf", "data_vencimento"], how="inner").drop(
+            "data_ref_tpf"
         )
 
     if month_start:
-        df = df.with_columns(pl.col("ExpirationDate").dt.truncate("1mo"))
+        df = df.with_columns(pl.col("data_vencimento").dt.truncate("1mo"))
 
-    return df.sort("TradeDate", "ExpirationDate")
+    return df.sort("data_referencia", "data_vencimento")
 
 
 def interpolate_rates(
@@ -145,7 +148,7 @@ def interpolate_rates(
         ...     expirations=["01-01-2027", "25-11-2027", "01-01-2030"],
         ... )
         shape: (3,)
-        Series: 'FlatFwdRate' [f64]
+        Series: 'taxa_interpolada' [f64]
         [
             0.13972
             0.134613
@@ -159,7 +162,7 @@ def interpolate_rates(
         ...     extrapolate=True,
         ... )
         shape: (2,)
-        Series: 'FlatFwdRate' [f64]
+        Series: 'taxa_interpolada' [f64]
         [
             0.13901
             0.13881
@@ -172,7 +175,7 @@ def interpolate_rates(
         ...     extrapolate=False,
         ... )
         shape: (2,)
-        Series: 'FlatFwdRate' [f64]
+        Series: 'taxa_interpolada' [f64]
         [
             0.135763
             null
@@ -182,16 +185,16 @@ def interpolate_rates(
         return pl.Series(dtype=pl.Float64)
 
     df_entrada = pl.DataFrame(
-        data={"TradeDate": dates, "ExpirationDate": expirations}
+        data={"data_referencia": dates, "data_vencimento": expirations}
     ).with_columns(
-        TradeDate=cv.converter_datas_expr("TradeDate"),
-        ExpirationDate=cv.converter_datas_expr("ExpirationDate"),
+        data_referencia=cv.converter_datas_expr("data_referencia"),
+        data_vencimento=cv.converter_datas_expr("data_vencimento"),
     )
     if df_entrada.is_empty():
         return pl.Series(dtype=pl.Float64)
 
     # Carrega dataset de taxas DI usando datas já convertidas do df_entrada
-    datas_unicas = df_entrada["TradeDate"].drop_nulls().unique().sort().to_list()
+    datas_unicas = df_entrada["data_referencia"].drop_nulls().unique().sort().to_list()
     df_ref = b3.futures(date=datas_unicas, contract_code="DI1", full_report=False)
     # Retorna Series vazia se nenhuma taxa for encontrada
     if df_ref.is_empty():
@@ -201,22 +204,22 @@ def interpolate_rates(
     # Isso garante que saberemos a ordem exata depois
     df_entrada = df_entrada.with_row_index("_temp_idx")
 
-    # Inicializa FlatFwdRate como None
+    # Inicializa taxa_interpolada como None
     df_entrada = df_entrada.with_columns(
-        BDaysToExp=bday.count_expr("TradeDate", "ExpirationDate"),
-        FlatFwdRate=None,
+        dias_uteis=bday.count_expr("data_referencia", "data_vencimento"),
+        taxa_interpolada=None,
     )
 
     # Lista para armazenar os blocos processados
     blocos_processados = []
 
     # Itera sobre cada data de referência única
-    for data_ref in df_entrada["TradeDate"].unique():
+    for data_ref in df_entrada["data_referencia"].unique():
         # 1. Filtra apenas as linhas desta data (Particionamento)
-        df_parcial = df_entrada.filter(pl.col("TradeDate") == data_ref)
+        df_parcial = df_entrada.filter(pl.col("data_referencia") == data_ref)
 
         # 2. Busca as taxas de referência para esta data
-        df_referencia = df_ref.filter(pl.col("TradeDate") == data_ref)
+        df_referencia = df_ref.filter(pl.col("data_referencia") == data_ref)
 
         # Se não houver dados de curva, adicionamos o bloco como está (com nulos)
         # e continuamos.
@@ -227,17 +230,17 @@ def interpolate_rates(
         # Inicializa o interpolador com taxas e dias úteis conhecidos
         interpolador = interpolator.Interpolator(
             method="flat_forward",
-            known_bdays=df_referencia["BDaysToExp"],
-            known_rates=df_referencia["SettlementRate"],
+            known_bdays=df_referencia["dias_uteis"],
+            known_rates=df_referencia["taxa_ajuste"],
             extrapolate=extrapolate,
         )
 
         # 4. A mágica: map_batches passa a Series inteira para o interpolador
         # O interpolador retorna uma Series, que o Polars alinha perfeitamente
         df_parcial = df_parcial.with_columns(
-            pl.col("BDaysToExp")
+            pl.col("dias_uteis")
             .map_batches(interpolador)  # Passa Series -> Recebe Series
-            .alias("FlatFwdRate")
+            .alias("taxa_interpolada")
         )
 
         blocos_processados.append(df_parcial)
@@ -249,7 +252,7 @@ def interpolate_rates(
     # O sort("_temp_idx") restaura a ordem original dos inputs
     df_saida = pl.concat(blocos_processados).sort("_temp_idx")
 
-    return df_saida["FlatFwdRate"].fill_nan(None)
+    return df_saida["taxa_interpolada"].fill_nan(None)
 
 
 def interpolate_rate(
@@ -315,9 +318,10 @@ def interpolate_rate(
 def available_dates() -> pl.Series:
     """Retorna as datas de negociação disponíveis para DI1.
 
-    Obtém valores distintos de 'TradeDate' para DI1, com base no dataset histórico
-    PR da B3 (mesmo utilizado por `futures`). Inclui apenas datas com preço e taxa
-    de ajuste já definidos; o pregão do dia corrente não está incluído.
+    Obtém valores distintos de 'data_referencia' para DI1, com base no dataset
+    histórico PR da B3 (mesmo utilizado por `futures`). Inclui apenas datas com
+    preço e taxa de ajuste já definidos; o pregão do dia corrente não está
+    incluído.
 
     Returns:
         Series ordenada de datas de negociação (dt.date) para as quais dados de
@@ -328,7 +332,7 @@ def available_dates() -> pl.Series:
         >>> # Série disponível no dataset PR começa em 2018-01-02
         >>> di1.available_dates().head(5)
         shape: (5,)
-        Series: 'TradeDate' [date]
+        Series: 'data_referencia' [date]
         [
             2018-01-02
             2018-01-03

{pyield-0.46.2 → pyield-0.46.4}/pyield/b3/futures/__init__.py

@@ -7,7 +7,7 @@ import pyield._internal.converters as cv
 from pyield import clock
 from pyield._internal.types import ArrayLike, DateLike, any_is_empty, is_collection
 from pyield.b3._contracts import normalizar_codigos_contrato
-from pyield.b3._validar_pregao import data_negociacao_valida
+from pyield.b3._validar_pregao import HORA_INICIO_INTRADAY, data_negociacao_valida
 from pyield.b3.futures import historical, intraday
 
 # A partir desse horário, os dados consolidados (SPR/PR) já estão disponíveis.
@@ -58,7 +58,7 @@ def futures(
         Lista de datas:
 
         >>> df = futures(["29-05-2024", "31-05-2024"], "DI1")
-        >>> df["TradeDate"].unique().sort().to_list()
+        >>> df["data_referencia"].unique().sort().to_list()
         [datetime.date(2024, 5, 29), datetime.date(2024, 5, 31)]
 
         Véspera de Natal e Ano Novo não têm pregão:
@@ -125,7 +125,7 @@ def _buscar_varias_datas(
     # Identifica datas que não vieram do cache
     datas_no_cache: set[dt.date] = set()
     for df in resultados:
-        datas_no_cache.update(df["TradeDate"].unique().to_list())
+        datas_no_cache.update(df["data_referencia"].unique().to_list())
     datas_faltantes = [d for d in datas_validas if d not in datas_no_cache]
 
     # Fallback individual apenas para datas faltantes
@@ -156,7 +156,7 @@ def _buscar_por_fonte(
             return df
         return intraday.intraday(codigos)
 
-    if horario >= intraday.HORA_INICIO_INTRADAY:
+    if horario >= HORA_INICIO_INTRADAY:
         # Intraday primeiro; historical como fallback
         df = intraday.intraday(codigos)
         if not df.is_empty():
@@ -178,7 +178,7 @@ def available_dates(contract_code: str) -> pl.Series:
         >>> from pyield.b3.futures import available_dates
         >>> available_dates("DI1").head(3)
         shape: (3,)
-        Series: 'TradeDate' [date]
+        Series: 'data_referencia' [date]
         [
             2018-01-02
             2018-01-03