pyield 0.47.0__tar.gz → 0.47.2__tar.gz

{pyield-0.47.0 → pyield-0.47.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyield
-Version: 0.47.0
+Version: 0.47.2
 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

pyield-0.47.2/pyield/__about__.py

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

{pyield-0.47.0 → pyield-0.47.2}/pyield/__init__.py

@@ -2,7 +2,7 @@ import logging
 
 from pyield import anbima, b3, bc, bday, ipca, selic, tn
 from pyield.__about__ import __version__
-from pyield.b3 import di1, futures, futures_intraday
+from pyield.b3 import di1, futures
 from pyield.clock import now, today
 from pyield.fwd import forward, forwards
 from pyield.interpolator import Interpolator
@@ -11,33 +11,31 @@ from pyield.selic.cpm import data as copom_options
 from pyield.tn import lft, ltn, ntnb, ntnb1, ntnbprinc, ntnc, ntnf, pre
 
 __all__ = [
+    "Interpolator",
     "__version__",
     "anbima",
-    "bc",
     "b3",
-    "ipca",
-    "tn",
+    "bc",
     "bday",
+    "copom_options",
     "di1",
-    "forwards",
     "forward",
+    "forwards",
     "futures",
-    "copom_options",
-    "Interpolator",
-    "today",
-    "now",
     "lft",
     "ltn",
+    "now",
     "ntnb",
-    "ntnbprinc",
     "ntnb1",
+    "ntnbprinc",
     "ntnc",
     "ntnf",
+    "ipca",
     "pre",
     "rmd",
-    "bday",
     "selic",
-    "futures_intraday",
+    "tn",
+    "today",
 ]
 
 # Configura o logger do pacote principal com um NullHandler

{pyield-0.47.0 → pyield-0.47.2}/pyield/_internal/data_cache.py

@@ -1,5 +1,4 @@
 import functools
-import io
 import logging
 from enum import Enum
 from typing import Literal
@@ -55,11 +54,8 @@ def _carregar_arquivo_github(url_arquivo: str) -> pl.DataFrame:
     # Garante que a requisição foi sucesso (200 OK), senão levanta erro
     response.raise_for_status()
 
-    # 2. Transforma os bytes em um objeto de arquivo em memória
-    file_buffer = io.BytesIO(response.content)
-
-    # 3. O Polars lê o buffer como se fosse um arquivo local
-    return pl.read_parquet(file_buffer)
+    # 2. O Polars lê o buffer como se fosse um arquivo local
+    return pl.read_parquet(response.content)
 
 
 @functools.lru_cache(maxsize=8)

pyield-0.47.2/pyield/b3/__init__.py

@@ -0,0 +1,27 @@
+from pyield.b3 import di1
+from pyield.b3.derivatives_intraday import derivatives_intraday_fetch
+from pyield.b3.di_over import di_over
+from pyield.b3.futures import (
+    futures,
+    futures_available_dates,
+    futures_enrich,
+    futures_intraday,
+)
+from pyield.b3.price_report import (
+    price_report_extract,
+    price_report_fetch,
+    price_report_read,
+)
+
+__all__ = [
+    "di_over",
+    "di1",
+    "futures",
+    "futures_available_dates",
+    "futures_enrich",
+    "futures_intraday",
+    "derivatives_intraday_fetch",
+    "price_report_extract",
+    "price_report_fetch",
+    "price_report_read",
+]

pyield-0.47.0/pyield/b3/intraday_derivatives.py → pyield-0.47.2/pyield/b3/derivatives_intraday.py

@@ -35,7 +35,6 @@ import requests
 from pyield import clock
 from pyield._internal.cache import ttl_cache
 from pyield._internal.retry import retry_padrao
-from pyield.b3._validar_pregao import intraday_disponivel
 
 URL_BASE_INTRADAY = "https://cotacao.b3.com.br/mds/api/v1/DerivativeQuotation"
 
@@ -111,7 +110,7 @@ def _processar_colunas_intraday(df: pl.DataFrame) -> pl.DataFrame:
     )
 
 
-def fetch_intraday_derivatives(contract_code: str) -> pl.DataFrame:
+def derivatives_intraday_fetch(contract_code: str) -> pl.DataFrame:
     """Busca cotações intraday brutas de derivativos da B3.
 
     Faz a chamada ao endpoint ``DerivativeQuotation`` e devolve um DataFrame
@@ -123,7 +122,8 @@ def fetch_intraday_derivatives(contract_code: str) -> pl.DataFrame:
     derivados devem ser feitos no módulo consumidor.
 
     Args:
-        contract_code: Código base do derivativo na B3.
+        contract_code: Código base do derivativo na B3
+            (ex.: ``DI1``, ``DOL``, ``DAP``, ``DDI``, ``FRC``, ``FRO``, ``IND``).
 
     Returns:
         DataFrame Polars com o payload normalizado da API.
@@ -150,21 +150,17 @@ def fetch_intraday_derivatives(contract_code: str) -> pl.DataFrame:
         * preco_oferta_compra (Float64): melhor oferta de compra (opcional).
         * preco_oferta_venda (Float64): melhor oferta de venda (opcional).
         * tipo_lado (String): tipo de lado (opcional).
-        * atualizado_as (Datetime): horário aproximado a que o dado se
-          refere (horário da consulta menos 15 min de atraso da fonte).
+        * horario_referencia (Time): horário aproximado a que os
+          dados se referem. A fonte intraday da B3 possui atraso de
+          ~15 min; este valor é calculado subtraindo esse atraso do
+          horário da consulta.
     """
-    if not intraday_disponivel():
-        return pl.DataFrame()
-
     dados_json = _buscar_json_intraday(contract_code)
     if not dados_json:
         return pl.DataFrame()
 
-    return (
-        _converter_json_intraday(dados_json)
-        .pipe(_processar_colunas_intraday)
-        .with_columns(
-            atualizado_as=clock.now() - dt.timedelta(minutes=15),
-        )
-        .sort("codigo_negociacao")
-    )
+    df = _converter_json_intraday(dados_json)
+    df = _processar_colunas_intraday(df)
+    horario = (clock.now() - dt.timedelta(minutes=15)).time()
+    df = df.with_columns(horario_referencia=horario)
+    return df.sort("codigo_negociacao")

{pyield-0.47.0 → pyield-0.47.2}/pyield/b3/di1.py

@@ -4,7 +4,7 @@ import pyield._internal.converters as cv
 from pyield import b3, bday, interpolator
 from pyield._internal.data_cache import obter_dataset_cacheado
 from pyield._internal.types import ArrayLike, DateLike, any_is_collection, any_is_empty
-from pyield.b3.futures import available_dates as _listar_datas
+from pyield.b3.futures import futures_available_dates as _listar_datas
 
 
 def data(

pyield-0.47.2/pyield/b3/futures/__init__.py

@@ -0,0 +1,153 @@
+import polars as pl
+
+import pyield._internal.converters as cv
+from pyield._internal.types import ArrayLike, DateLike, any_is_empty
+from pyield.b3._validar_pregao import data_negociacao_valida
+from pyield.b3.futures import historical, intraday
+
+
+def futures_enrich(
+    df: pl.DataFrame,
+    contract_code: str,
+) -> pl.DataFrame:
+    """Enriquece DataFrame bruto do Price Report (PR) da B3.
+
+    Aceita um DataFrame com colunas no schema original da B3
+    (ex.: ``TradDt``, ``TckrSymb``) ou já renomeadas para o padrão
+    PYield. Adiciona data de vencimento, dias úteis/corridos e
+    colunas derivadas (dv01, taxa_forward) conforme o contrato.
+
+    Args:
+        df: DataFrame com dados do PR da B3.
+        contract_code: Código do contrato futuro
+            (ex.: "DI1", "DOL").
+
+    Returns:
+        DataFrame Polars enriquecido e ordenado.
+    """
+    return historical.enrich(df, contract_code)
+
+
+def futures(
+    date: DateLike | ArrayLike,
+    contract_code: str,
+) -> pl.DataFrame:
+    """Busca dados de um contrato futuro da B3 para a data de referência.
+
+    Dados obtidos do dataset PR cacheado no GitHub (disponível desde 2018).
+    Para dados do pregão corrente, use ``futures_intraday``.
+
+    Args:
+        date: Data de referência para consulta ou coleção de datas.
+            Quando uma coleção é fornecida, os dados são buscados para cada
+            data individualmente e concatenados. Datas inválidas (feriados,
+            fins de semana, futuras) são silenciosamente ignoradas.
+        contract_code: Código do contrato futuro na B3. Contratos
+            disponíveis no cache histórico:
+            - Juros: DI1, DDI, FRC, FRO, DAP
+            - Moedas: DOL, WDO
+            - Índices: IND, WIN
+
+    Returns:
+        DataFrame Polars com os dados do contrato informado.
+
+    Examples:
+        >>> df = futures("31-05-2024", "DI1")
+        >>> df = futures("31-05-2024", "DAP")
+
+        Lista de datas:
+
+        >>> df = futures(["29-05-2024", "31-05-2024"], "DI1")
+        >>> 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:
+
+        >>> futures("24-12-2024", "DI1").is_empty()
+        True
+        >>> futures("31-12-2024", "DI1").is_empty()
+        True
+
+        Data futura e fim de semana retornam DataFrame vazio:
+
+        >>> import datetime as dt
+        >>> amanha = dt.date.today() + dt.timedelta(days=1)
+        >>> futures(amanha, "DI1").is_empty()
+        True
+        >>> futures("04-01-2025", "DI1").is_empty()  # sábado
+        True
+
+    """
+    if any_is_empty(date, contract_code):
+        return pl.DataFrame()
+
+    dados_convertidos = cv.converter_datas(date)
+    if isinstance(dados_convertidos, pl.Series):
+        datas_validas = []
+        for d in dados_convertidos:
+            if d is not None and data_negociacao_valida(d):
+                datas_validas.append(d)
+        return historical._buscar_do_cache(datas_validas, contract_code)
+
+    if not data_negociacao_valida(dados_convertidos):
+        return pl.DataFrame()
+
+    return historical.historical(dados_convertidos, contract_code)
+
+
+def futures_intraday(
+    contract_code: str,
+) -> pl.DataFrame:
+    """Busca dados intraday de contratos futuros da B3.
+
+    Retorna os dados mais recentes do pregão corrente, com atraso
+    aproximado de 15 minutos. Para dados históricos consolidados,
+    use ``futures``.
+
+    Args:
+        contract_code: Código do contrato futuro na B3
+            (ex.: 'DI1', 'DAP', 'DOL').
+
+    Returns:
+        DataFrame Polars com dados intraday. Retorna DataFrame vazio
+        fora do horário de pregão.
+
+    Notes:
+        As colunas com prefixo ``preco_`` aparecem para contratos cotados
+        por preço (ex.: DOL, IND). As com prefixo ``taxa_`` aparecem para
+        contratos cotados por taxa (ex.: DI1, DAP, DDI, FRC, FRO).
+    """
+    if not contract_code:
+        return pl.DataFrame()
+
+    return intraday.intraday(contract_code)
+
+
+def futures_available_dates(contract_code: str) -> pl.Series:
+    """Retorna as datas de negociação disponíveis no dataset cacheado.
+
+    Args:
+        contract_code: Código do contrato futuro na B3 (ex.: DI1, DOL).
+
+    Returns:
+        Series ordenada de datas (Date) para as quais há dados de ajuste.
+
+    Examples:
+        >>> from pyield.b3.futures import futures_available_dates
+        >>> futures_available_dates("DI1").head(3)
+        shape: (3,)
+        Series: 'data_referencia' [date]
+        [
+            2018-01-02
+            2018-01-03
+            2018-01-04
+        ]
+    """
+    return historical.listar_datas_disponiveis(contract_code)
+
+
+__all__ = [
+    "futures",
+    "futures_available_dates",
+    "futures_intraday",
+]

{pyield-0.47.0 → pyield-0.47.2}/pyield/b3/futures/common.py

@@ -2,6 +2,10 @@ import polars as pl
 
 from pyield import bday
 
+# Lista de contratos que negociam por taxa (juros/cupom).
+# Nestes contratos, as colunas OHLC são taxas e precisam ser divididas por 100.
+CONTRATOS_TAXA = {"DI1", "DAP", "DDI", "FRC", "FRO"}
+
 _MAPA_MESES: dict[str, int] = {
     "F": 1,
     "G": 2,

{pyield-0.47.0 → pyield-0.47.2}/pyield/b3/futures/historical.py

@@ -1,17 +1,13 @@
 import datetime as dt
 
 import polars as pl
+import polars.selectors as cs
 
 from pyield import bday
 from pyield._internal.data_cache import obter_dataset_cacheado
-from pyield.b3._contracts import normalizar_codigos_contrato
-from pyield.b3.futures.common import adicionar_vencimento, expr_dv01
+from pyield.b3.futures.common import CONTRATOS_TAXA, adicionar_vencimento, expr_dv01
 from pyield.fwd import forwards
 
-# Lista de contratos que negociam por taxa (juros/cupom).
-# Nestes contratos, as colunas OHLC são taxas e precisam ser divididas por 100.
-CONTRATOS_TAXA = {"DI1", "DAP", "DDI", "FRC", "FRO"}
-
 # Renomeação preco_* → taxa_* para contratos cotados por taxa.
 # Bid/Ask são invertidos: BestBidPric (bid em PU) = menor taxa = venda de taxa;
 # BestAskPric (ask em PU) = maior taxa = compra de taxa.
@@ -27,6 +23,55 @@ _PRECO_PARA_TAXA = {
     "preco_limite_maximo": "taxa_limite_maximo",
 }
 
+# Colunas de saída para contratos cotados por preço (DOL, WDO, IND, WIN).
+_COLUNAS_CONTRATO_PRECO = (
+    "data_referencia",
+    "codigo_negociacao",
+    "data_vencimento",
+    "dias_uteis",
+    "dias_corridos",
+    "contratos_abertos",
+    "numero_negocios",
+    "volume_negociado",
+    "volume_financeiro",
+    "preco_limite_minimo",
+    "preco_limite_maximo",
+    "preco_abertura",
+    "preco_minimo",
+    "preco_maximo",
+    "preco_medio",
+    "preco_fechamento",
+    "preco_ultima_oferta_compra",
+    "preco_ultima_oferta_venda",
+    "preco_ajuste",
+)
+
+# Colunas de saída para contratos cotados por taxa (DI1, DAP, DDI, FRC, FRO).
+_COLUNAS_CONTRATO_TAXA = (
+    "data_referencia",
+    "codigo_negociacao",
+    "data_vencimento",
+    "dias_uteis",
+    "dias_corridos",
+    "dv01",
+    "contratos_abertos",
+    "numero_negocios",
+    "volume_negociado",
+    "volume_financeiro",
+    "preco_ajuste",
+    "taxa_limite_minimo",
+    "taxa_limite_maximo",
+    "taxa_abertura",
+    "taxa_minima",
+    "taxa_maxima",
+    "taxa_media",
+    "taxa_fechamento",
+    "taxa_ultima_oferta_venda",
+    "taxa_ultima_oferta_compra",
+    "taxa_ajuste",
+    "taxa_forward",
+)
+
 # Normaliza o schema XML bruto da B3 para o padrão de colunas deste módulo.
 _RENOMEAR_COLUNAS_PR = {
     "TradDt": "data_referencia",
@@ -49,25 +94,95 @@ _RENOMEAR_COLUNAS_PR = {
 }
 
 
-def _normalizar_colunas_pr(df: pl.DataFrame) -> pl.DataFrame:
-    return df.rename({k: v for k, v in _RENOMEAR_COLUNAS_PR.items() if k in df.columns})
+def _obter_cache_filtrado(codigo_contrato: str) -> pl.DataFrame:
+    """Carrega o dataset PR cacheado e filtra por contrato."""
+    return obter_dataset_cacheado("futures").filter(
+        pl.col("TckrSymb").str.starts_with(codigo_contrato)
+    )
+
+
+def _enriquecer_dados(df: pl.DataFrame, codigo_contrato: str) -> pl.DataFrame:
+    df = df.with_columns(
+        dias_uteis=bday.count_expr("data_referencia", "data_vencimento"),
+        dias_corridos=(
+            pl.col("data_vencimento") - pl.col("data_referencia")
+        ).dt.total_days(),
+    ).filter(pl.col("dias_corridos") > 0)
+
+    eh_taxa = codigo_contrato in CONTRATOS_TAXA
+    if eh_taxa:
+        df = df.rename(_PRECO_PARA_TAXA, strict=False)
+        df = df.with_columns(cs.starts_with("taxa_").truediv(100).round(6))
+
+    if codigo_contrato == "DI1":
+        df = df.with_columns(
+            dv01=expr_dv01("dias_uteis", "taxa_ajuste", "preco_ajuste")
+        )
+
+    if codigo_contrato in {"DI1", "DAP"}:
+        df = df.with_columns(
+            taxa_forward=forwards(bdays=df["dias_uteis"], rates=df["taxa_ajuste"])
+        )
+
+    return df
 
 
-def _obter_pr_normalizado() -> pl.DataFrame:
-    """Carrega o dataset PR e normaliza nomes de colunas."""
-    df = obter_dataset_cacheado("futures")
-    return _normalizar_colunas_pr(df)
+def _selecionar_colunas_saida(df: pl.DataFrame, codigo_contrato: str) -> pl.DataFrame:
+    if codigo_contrato in CONTRATOS_TAXA:
+        colunas = _COLUNAS_CONTRATO_TAXA
+    else:
+        colunas = _COLUNAS_CONTRATO_PRECO
+    return df.select(c for c in colunas if c in df.columns)
+
+
+def _buscar_do_cache(datas: list[dt.date], codigo_contrato: str) -> pl.DataFrame:
+    """Carrega histórico de futuros do dataset PR para uma lista de datas."""
+    if not datas:
+        return pl.DataFrame()
+
+    df = _obter_cache_filtrado(codigo_contrato)
+    df = df.filter(pl.col("TradDt").is_in(datas))
+    if df.is_empty():
+        return pl.DataFrame()
+
+    return enrich(df, codigo_contrato)
+
+
+def enrich(df: pl.DataFrame, codigo_contrato: str) -> pl.DataFrame:
+    """Enriquece DataFrame bruto do Price Report (PR) da B3.
+
+    Aceita um DataFrame com colunas no schema original da B3 (ex.:
+    ``TradDt``, ``TckrSymb``) ou já renomeadas para o padrão PYield.
+    Adiciona data de vencimento, dias úteis/corridos e colunas derivadas
+    (dv01, taxa_forward) conforme o contrato.
+
+    Args:
+        df: DataFrame com dados do PR da B3.
+        codigo_contrato: Código do contrato futuro (ex.: "DI1", "DOL").
+
+    Returns:
+        DataFrame Polars enriquecido e ordenado.
+    """
+    if df.is_empty():
+        return pl.DataFrame()
+
+    df = df.rename(_RENOMEAR_COLUNAS_PR)
+    df = adicionar_vencimento(df, codigo_contrato, coluna_ticker="codigo_negociacao")
+    df = _enriquecer_dados(df, codigo_contrato)
+    df = _selecionar_colunas_saida(df, codigo_contrato)
+
+    return df.sort("data_referencia", "data_vencimento")
 
 
 def historical(
     data: dt.date,
-    codigo_contrato: str | list[str],
+    codigo_contrato: str,
 ) -> pl.DataFrame:
     """Busca histórico de futuros no dataset PR cacheado.
 
     Args:
         data: Data de negociação.
-        codigo_contrato: Código(s) do contrato futuro na B3.
+        codigo_contrato: Código do contrato futuro na B3.
 
     Returns:
         DataFrame Polars com dados históricos de futuros.
@@ -113,10 +228,10 @@ def historical(
         Usa exclusivamente o dataset PR cacheado no GitHub. Contratos
         disponíveis: DI1, DDI, FRC, FRO, DAP, DOL, WDO, IND, WIN.
 
-        As colunas com prefixo ``preco_`` aparecem para contratos cotados por
-        preço (ex.: DOL, IND). As com prefixo ``taxa_`` aparecem para contratos
-        cotados por taxa (ex.: DI1, DAP, DDI, FRC, FRO). Nem todas as colunas
-        estarão presentes em todos os contratos.
+        As colunas com prefixo ``preco_`` aparecem para contratos cotados
+        por preço (ex.: DOL, IND). As com prefixo ``taxa_`` aparecem para
+        contratos cotados por taxa (ex.: DI1, DAP, DDI, FRC, FRO). Nem
+        todas as colunas estarão presentes em todos os contratos.
 
         ``*_fechamento`` é o último negócio realizado (last trade).
         ``*_ultima_oferta_*`` é o bid/ask ao fim do pregão — não
@@ -125,139 +240,16 @@ def historical(
         ``taxa_ultima_oferta_compra`` = maior taxa (ask em PU),
         ``taxa_ultima_oferta_venda`` = menor taxa (bid em PU).
     """
-    codigos = normalizar_codigos_contrato(codigo_contrato)
-    if not codigos:
-        return pl.DataFrame()
-
-    dataframes = [
-        df
-        for codigo in codigos
-        if not (df := _obter_futuros_pr([data], codigo)).is_empty()
-    ]
-
-    if not dataframes:
-        return pl.DataFrame()
-
-    if len(dataframes) == 1:
-        return dataframes[0]
-
-    df_resultado = pl.concat(dataframes, how="diagonal_relaxed")
-    colunas_ordenacao = [
-        coluna
-        for coluna in ["data_referencia", "codigo_negociacao", "data_vencimento"]
-        if coluna in df_resultado.columns
-    ]
-    if not colunas_ordenacao:
-        return df_resultado
-
-    return df_resultado.sort(*colunas_ordenacao)
-
-
-def _obter_futuros_pr(datas: list[dt.date], codigo_contrato: str) -> pl.DataFrame:
-    """Carrega histórico de futuros do dataset PR para uma lista de datas."""
-    if not datas:
-        return pl.DataFrame()
-
-    df = _obter_pr_normalizado()
-    df = _filtrar_e_renomear(df, datas, codigo_contrato)
-    if df.is_empty():
-        return pl.DataFrame()
-
-    df = adicionar_vencimento(df, codigo_contrato, coluna_ticker="codigo_negociacao")
-    df = _enriquecer_dados(df, codigo_contrato)
-    df = _selecionar_colunas_saida(df)
-
-    return df.sort("data_referencia", "data_vencimento")
+    return _buscar_do_cache([data], codigo_contrato)
 
 
 def listar_datas_disponiveis(codigo_contrato: str) -> pl.Series:
     """Lista datas disponíveis no dataset PR para um contrato futuro."""
     return (
-        _obter_pr_normalizado()
-        .filter(pl.col("codigo_negociacao").str.starts_with(codigo_contrato))
-        .get_column("data_referencia")
+        _obter_cache_filtrado(codigo_contrato)
+        .get_column("TradDt")
         .drop_nulls()
         .unique()
         .sort()
         .alias("data_referencia")
     )
-
-
-def _filtrar_e_renomear(
-    df: pl.DataFrame, datas: list[dt.date], codigo_contrato: str
-) -> pl.DataFrame:
-    return df.filter(
-        pl.col("data_referencia").is_in(datas),
-        pl.col("codigo_negociacao").str.starts_with(codigo_contrato),
-    )
-
-
-def _enriquecer_dados(df: pl.DataFrame, codigo_contrato: str) -> pl.DataFrame:
-    df = df.with_columns(
-        dias_uteis=bday.count_expr("data_referencia", "data_vencimento"),
-        dias_corridos=(
-            pl.col("data_vencimento") - pl.col("data_referencia")
-        ).dt.total_days(),
-    ).filter(pl.col("dias_corridos") > 0)
-
-    eh_taxa = codigo_contrato in CONTRATOS_TAXA
-    if eh_taxa:
-        df = df.rename({k: v for k, v in _PRECO_PARA_TAXA.items() if k in df.columns})
-
-    if eh_taxa:
-        colunas_taxa = [c for c in df.columns if c.startswith("taxa_")]
-        df = df.with_columns(pl.col(colunas_taxa).truediv(100).round(6))
-
-    if (
-        codigo_contrato == "DI1"
-        and "preco_ajuste" in df.columns
-        and "taxa_ajuste" in df.columns
-    ):
-        df = df.with_columns(
-            dv01=expr_dv01("dias_uteis", "taxa_ajuste", "preco_ajuste")
-        )
-
-    if codigo_contrato in {"DI1", "DAP"} and "taxa_ajuste" in df.columns:
-        df = df.with_columns(
-            taxa_forward=forwards(bdays=df["dias_uteis"], rates=df["taxa_ajuste"])
-        )
-
-    return df
-
-
-def _selecionar_colunas_saida(df: pl.DataFrame) -> pl.DataFrame:
-    ordem_preferida = [
-        "data_referencia",
-        "codigo_negociacao",
-        "data_vencimento",
-        "dias_uteis",
-        "dias_corridos",
-        "dv01",
-        "contratos_abertos",
-        "numero_negocios",
-        "volume_negociado",
-        "volume_financeiro",
-        "preco_limite_minimo",
-        "preco_limite_maximo",
-        "preco_abertura",
-        "preco_minimo",
-        "preco_maximo",
-        "preco_medio",
-        "preco_fechamento",
-        "preco_ultima_oferta_compra",
-        "preco_ultima_oferta_venda",
-        "preco_ajuste",
-        "taxa_limite_minimo",
-        "taxa_limite_maximo",
-        "taxa_abertura",
-        "taxa_minima",
-        "taxa_maxima",
-        "taxa_media",
-        "taxa_fechamento",
-        "taxa_ultima_oferta_venda",
-        "taxa_ultima_oferta_compra",
-        "taxa_ajuste",
-        "taxa_forward",
-    ]
-    colunas_existentes = [c for c in ordem_preferida if c in df.columns]
-    return df.select(colunas_existentes)