pyield 0.45.0__tar.gz → 0.45.2__tar.gz

{pyield-0.45.0 → pyield-0.45.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyield
-Version: 0.45.0
+Version: 0.45.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.45.2/pyield/__about__.py

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

{pyield-0.45.0 → pyield-0.45.2}/pyield/_internal/converters.py

@@ -7,6 +7,15 @@ from pyield._internal import types
 from pyield._internal.types import ArrayLike, DateLike
 
 
+def data_referencia_valida(date: dt.date | None) -> bool:
+    """Verifica se a data é dia útil e não está no futuro."""
+    if date is None:
+        return False
+    from pyield import bday, clock  # noqa: PLC0415
+
+    return bday.is_business_day(date) and date <= clock.today()
+
+
 def converter_datas_expr(expr: pl.Expr | str) -> pl.Expr:
     """Converte expressão Polars para ``Date`` com parse tolerante por linha.
 

{pyield-0.45.0 → pyield-0.45.2}/pyield/anbima/__init__.py

@@ -3,13 +3,14 @@ from pyield.anbima.ettj_intraday import intraday_ettj
 from pyield.anbima.ettj_last import last_ettj
 from pyield.anbima.ima import last_ima
 from pyield.anbima.imaq import imaq
-from pyield.anbima.tpf import tpf_data, tpf_maturities
+from pyield.anbima.tpf import fetch_tpf, tpf, tpf_maturities
 
 __all__ = [
     "last_ima",
     "imaq",
-    "tpf_data",
+    "tpf",
     "tpf_maturities",
+    "fetch_tpf",
     "last_ettj",
     "intraday_ettj",
     "tpf_difusao",

pyield-0.45.2/pyield/anbima/imaq.py

@@ -0,0 +1,170 @@
+"""
+Exemplo de página HTML:
+    Título Codigo Selic  Código ISIN Data de Vencimento Quantidade em Mercado (1.000 Títulos)    PU (R$) Valor de Mercado (R$ Mil)  Variação da Quantidade  (1.000 Títulos)        Status do Titulo
+       LTN       100000 BRSTNCLTN863         01/10/2025                           115.870,772 997,241543               115.551.147                                    0,000 Participante Definitivo
+       LTN       100000 BRSTNCLTN7U7         01/01/2026                           176.807,732 963,001853               170.266.174                                   -1,987 Participante Definitivo
+       LTN       100000 BRSTNCLTN8B5         01/04/2026                           115.826,847 931,607124               107.905.116                                    0,000 Participante Definitivo
+"""  # noqa
+
+import datetime as dt
+
+import polars as pl
+import polars.selectors as ps
+import requests
+from lxml.html import HTMLParser
+from lxml.html import fromstring as html_fromstring
+
+import pyield._internal.converters as cv
+from pyield._internal.cache import ttl_cache
+from pyield._internal.retry import retry_padrao
+from pyield._internal.types import DateLike
+
+URL_IMA = "https://www.anbima.com.br/informacoes/ima/ima-quantidade-mercado.asp"
+
+
+@ttl_cache()
+@retry_padrao
+def _buscar_conteudo_url(data_referencia: dt.date) -> bytes:
+    data_referencia_str = data_referencia.strftime("%d/%m/%Y")
+    payload = {
+        "Tipo": "",
+        "DataRef": "",
+        "Pai": "ima",
+        "Dt_Ref_Ver": "20250117",
+        "Dt_Ref": f"{data_referencia_str}",
+    }
+
+    resposta = requests.post(URL_IMA, data=payload, timeout=10)
+    resposta.raise_for_status()
+    if "Não há dados disponíveis" in resposta.text:
+        return b""
+    return resposta.content
+
+
+def _normalizar_nome_coluna(texto: str) -> str:
+    """Normaliza cabeçalhos removendo quebras de linha e espaços extras."""
+    return " ".join(texto.strip().split())
+
+
+def _parsear_tabelas_html(html_content: bytes) -> pl.DataFrame:
+    """Parseia tabelas HTML com lxml e retorna DataFrame via read_csv.
+
+    Extrai dados das tabelas aninhadas (com parent::td),
+    converte para CSV (separador tab) e lê com Polars.
+    """
+    html_content = html_content.replace(b"<br>", b" ").replace(b"<BR>", b" ")
+
+    parser = HTMLParser(encoding="iso-8859-1")
+    tree = html_fromstring(html_content, parser=parser)
+
+    nested_tables = tree.xpath("//table[@width='100%'][parent::td]")
+
+    linhas = []
+    nomes_colunas = None
+
+    for table in nested_tables:  # type: ignore[misc]
+        headers = table.xpath(".//thead//th")
+        if not nomes_colunas:
+            nomes_colunas = [_normalizar_nome_coluna(h.text_content()) for h in headers]
+
+        data_rows = table.xpath(".//tbody//tr[td]")
+        for row in data_rows:
+            cells = row.xpath(".//td")
+            if len(cells) != len(nomes_colunas):
+                continue
+            linhas.append("\t".join(c.text_content().strip() for c in cells))
+
+    if not linhas or not nomes_colunas:
+        return pl.DataFrame()
+
+    cabecalho = "\t".join(nomes_colunas)
+    csv_bytes = ("\n".join([cabecalho, *linhas])).encode("utf-8")
+    return pl.read_csv(
+        csv_bytes,
+        separator="\t",
+        infer_schema=False,
+        null_values="--",
+    )
+
+
+def _numero_br(coluna: str) -> pl.Expr:
+    """Converte coluna string no formato numérico brasileiro para Float64."""
+    return (
+        pl.col(coluna)
+        .str.replace_all(".", "", literal=True)
+        .str.replace(",", ".", literal=True)
+        .cast(pl.Float64)
+    )
+
+
+def _inteiro_m(coluna: str) -> pl.Expr:
+    """Converte coluna numérica BR em milhares para inteiro (unidades)."""
+    return (_numero_br(coluna) * 1000).round(0).cast(pl.Int64)
+
+
+def _processar_df(df: pl.DataFrame, data_referencia: dt.date) -> pl.DataFrame:
+    """Filtra, converte tipos e aplica transformações numéricas."""
+    return (
+        df.with_columns(ps.string().str.strip_chars().name.keep())
+        .filter(
+            pl.col("Data de Vencimento").is_not_null(),
+            pl.col("Título") != "Título",
+        )
+        .unique(subset="Código ISIN")
+        .select(
+            Date=data_referencia,
+            BondType=pl.col("Título"),
+            MaturityDate=pl.col("Data de Vencimento").str.to_date(format="%d/%m/%Y"),
+            SelicCode=pl.col("Codigo Selic").cast(pl.Int64),
+            ISIN=pl.col("Código ISIN"),
+            Price=_numero_br("PU (R$)"),
+            MarketQuantity=_inteiro_m("Quantidade em Mercado (1.000 Títulos)"),
+            MarketValue=_inteiro_m("Valor de Mercado (R$ Mil)"),
+            QuantityVariation=_inteiro_m("Variação da Quantidade (1.000 Títulos)"),
+            BondStatus=pl.col("Status do Titulo"),
+        )
+        .sort("BondType", "MaturityDate")
+    )
+
+
+def imaq(date: DateLike) -> pl.DataFrame:
+    """Consulta e processa dados de estoque IMA-Q da ANBIMA para uma data.
+
+    Args:
+        date: Data de referência. Apenas os últimos 5 dias úteis estão disponíveis;
+            o dado do dia anterior costuma ser publicado ao longo do dia.
+
+    Returns:
+        DataFrame com dados processados ou DataFrame vazio se a data for
+        inválida ou não houver dados disponíveis.
+
+    Output Columns:
+        - Date (Date): data de referência dos dados.
+        - BondType (String): tipo do título (LTN, NTN-B, NTN-F, LFT, …).
+        - MaturityDate (Date): data de vencimento do título.
+        - SelicCode (Int64): código SELIC do título.
+        - ISIN (String): código ISIN (International Securities Id Number).
+        - Price (Float64): PU do título em R$.
+        - MarketQuantity (Int64): quantidade em mercado (unidades).
+        - MarketValue (Int64): valor de mercado em R$.
+        - QuantityVariation (Int64): variação diária da quantidade.
+        - BondStatus (String): status do título.
+
+    Notes:
+        Valores convertidos para unidades puras (ex: MarketQuantity × 1.000).
+
+    Examples:
+        >>> yd.anbima.imaq("04-02-2026")  # doctest: +SKIP
+    """
+    data = cv.converter_datas(date)
+    if not cv.data_referencia_valida(data):
+        return pl.DataFrame()
+
+    url_content = _buscar_conteudo_url(data)
+    if not url_content:
+        return pl.DataFrame()
+
+    df = _parsear_tabelas_html(url_content)
+    if df.is_empty():
+        return pl.DataFrame()
+    return _processar_df(df, data)

{pyield-0.45.0 → pyield-0.45.2}/pyield/anbima/tpf.py

@@ -8,16 +8,11 @@ import polars.selectors as cs
 import requests
 from requests.exceptions import HTTPError, RequestException
 
-from pyield import bday, clock
-from pyield._internal.converters import converter_datas
+from pyield import bday
+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, any_is_empty
-from pyield.b3 import di1
-from pyield.bc.ptax_api import ptax
-from pyield.tn.ntnb import duration as duration_b
-from pyield.tn.ntnc import duration as duration_c
-from pyield.tn.ntnf import duration as duration_f
+from pyield._internal.types import DateLike
 
 BOND_TYPES = Literal["LFT", "NTN-B", "NTN-C", "LTN", "NTN-F", "PRE"]
 
@@ -131,89 +126,9 @@ def _processar_df_bruto(df: pl.DataFrame) -> pl.DataFrame:
             cs.contains("Rate").truediv(100).round(6),
             cs.ends_with("Date").str.to_date(format="%Y%m%d"),
         )
-        .with_columns(
-            BDToMat=bday.count_expr("ReferenceDate", "MaturityDate"),
-        )
-    )
-    return df
-
-
-def _calcular_duracao_por_linha(linha: dict) -> float:
-    """Função auxiliar que será aplicada a cada linha do struct."""
-    # Mapeia o BondType para a função de duration correspondente
-    # Isso torna a lógica dentro do lambda ainda mais limpa
-    tipo_titulo = linha["BondType"]
-    if tipo_titulo == "LTN":
-        return linha["BDToMat"] / 252  # A lógica da LTN depende apenas do BDToMat
-
-    funcoes_duracao = {
-        "NTN-F": duration_f,
-        "NTN-B": duration_b,
-        "NTN-C": duration_c,
-    }
-
-    func_duracao = funcoes_duracao.get(tipo_titulo)  # Busca da função correta
-    if func_duracao:
-        return func_duracao(
-            linha["ReferenceDate"],
-            linha["MaturityDate"],
-            linha["IndicativeRate"],
-        )
-    # Se o BondType não for reconhecido, retorna 0.0 (LFT ou outros)
-    return 0.0
-
-
-def _adicionar_duracao(df_input: pl.DataFrame) -> pl.DataFrame:
-    """Adiciona a coluna 'Duration' ao DataFrame Polars de forma otimizada."""
-    colunas_necessarias = [
-        "BondType",
-        "ReferenceDate",
-        "MaturityDate",
-        "IndicativeRate",
-        "BDToMat",  # Necessário para LTN
-    ]
-    # Adiciona a coluna Duration
-    df = df_input.with_columns(
-        pl.struct(colunas_necessarias)
-        .map_elements(_calcular_duracao_por_linha, return_dtype=pl.Float64)
-        .alias("Duration")
-    )
-    return df
-
-
-def _adicionar_prazo_medio(df: pl.DataFrame) -> pl.DataFrame:
-    # Na metodologia do Tesouro Nacional, a maturidade média é a mesma que a duração
-    df = df.with_columns(
-        pl.when(pl.col("BondType") == "LFT")
-        .then(pl.col("BDToMat") / 252)
-        .otherwise("Duration")
-        .alias("AvgMaturity")
-    )
-    return df
-
-
-def _adicionar_dv01(df_input: pl.DataFrame, data_ref: dt.date) -> pl.DataFrame:
-    """Adiciona as colunas de DV01 ao DataFrame."""
-    expr_duracao_mod = pl.col("Duration") / (1 + pl.col("IndicativeRate"))
-    df = df_input.with_columns(DV01=0.0001 * expr_duracao_mod * pl.col("Price"))
-
-    # DV01 em USD
-    try:
-        taxa_ptax = ptax(date=data_ref)
-        df = df.with_columns(DV01USD=pl.col("DV01") / taxa_ptax)
-    except Exception as e:
-        logger.error("Erro ao adicionar DV01 em USD: %s", e)
-    return df
-
-
-def _adicionar_taxa_di(df: pl.DataFrame, data_ref: dt.date) -> pl.DataFrame:
-    """Adiciona a coluna de taxa DI ao DataFrame."""
-    taxas_di = di1.interpolate_rates(
-        dates=data_ref,
-        expirations=df["MaturityDate"],
-        extrapolate=True,
+        # Substituir eventuais NaNs por None para compatibilidade com bancos de dados
+        .with_columns(cs.float().fill_nan(None))
     )
-    df = df.with_columns(DIRate=taxas_di)
     return df
 
 
@@ -225,22 +140,10 @@ def _selecionar_e_ordenar_colunas(df: pl.DataFrame) -> pl.DataFrame:
         "SelicCode",
         "IssueBaseDate",
         "MaturityDate",
-        "BDToMat",
-        "Duration",
-        "AvgMaturity",
-        "DV01",
-        "DV01USD",
         "Price",
         "BidRate",
         "AskRate",
         "IndicativeRate",
-        "DIRate",
-        # "StdDev",
-        # "LowerBoundRateD0",
-        # "UpperBoundRateD0",
-        # "LowerBoundRateD1",
-        # "UpperBoundRateD1",
-        "Criteria",
     ]
     ordem_colunas = [col for col in ordem_colunas if col in df.columns]
     return df.select(ordem_colunas).sort("BondType", "MaturityDate")
@@ -291,13 +194,6 @@ def _buscar_dados_tpf(date: dt.date) -> pl.DataFrame:
 
         df = _ler_csv(csv_texto)
         df = _processar_df_bruto(df)
-        df = _adicionar_duracao(df)
-        df = _adicionar_prazo_medio(df)
-        df = _adicionar_dv01(df, date)
-        df = _adicionar_taxa_di(df, date)
-        df = _selecionar_e_ordenar_colunas(df)
-        # Substituir eventuais NaNs por None para compatibilidade com bancos de dados
-        df = df.with_columns(cs.float().fill_nan(None))
 
         return df
 
@@ -324,24 +220,21 @@ def _buscar_dados_tpf(date: dt.date) -> pl.DataFrame:
         raise
 
 
-def tpf_data(
+def tpf(
     date: DateLike,
     bond_type: BOND_TYPES | None = None,
-    fetch_from_source: bool = False,
 ) -> 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. A obtenção dos dados segue uma hierarquia de fontes para
-    otimizar o desempenho e o acesso.
+    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 os resultados por um tipo de título
-            específico (ex: 'LTN', 'NTN-B'). Por padrão, retorna todos os tipos.
-        fetch_from_source (bool, optional): Se True, força a função a ignorar o
-            cache e buscar os dados diretamente da fonte (ANBIMA).
-            Padrão é False.
+        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.
@@ -350,7 +243,7 @@ def tpf_data(
 
     Examples:
         >>> from pyield import anbima
-        >>> df = anbima.tpf_data(date="06-02-2026")
+        >>> df = anbima.tpf(date="06-02-2026")
 
     Data columns:
         - BondType: Tipo do título público (e.g., 'LTN', 'NTN-B').
@@ -358,53 +251,36 @@ def tpf_data(
         - SelicCode: Código do título no SELIC.
         - IssueBaseDate: Data base ou de emissão do título.
         - MaturityDate: Data de vencimento do título.
-        - BDToMat: Número de dias úteis entre a data de referência e o vencimento.
-        - Duration: Macaulay Duration do título em anos.
-        - AvgMaturity: Prazo médio do título (em anos), conforme metodologia
-            do Tesouro Nacional.
-        - DV01: Variação financeira no preço do título (em BRL) para uma
-            mudança de 1 basis point (0,01%) na taxa de juros.
-        - DV01USD: O mesmo que DV01, mas convertido para USD pela PTAX do dia.
-        - Price: Preço Unitário (PU) do título na data de referência.
-        - BidRate: Taxa de compra em formato decimal (e.g., 0.10 para 10%).
-        - AskRate: Taxa de venda em formato decimal.
-        - IndicativeRate: Taxa indicativa em formato decimal.
-        - DIRate: Taxa DI interpolada (flatforward) no vencimento do título.
-        - StdDev: Desvio padrão da taxa indicativa.
-        - LowerBoundRateD0: Limite inferior do intervalo indicativo para D+0.
-        - UpperBoundRateD0: Limite superior do intervalo indicativo para D+0.
-        - LowerBoundRateD1: Limite inferior do intervalo indicativo para D+1.
-        - UpperBoundRateD1: Limite superior do intervalo indicativo para D+1.
-        - Criteria: Critério utilizado pela ANBIMA para o cálculo.
+        - Price: Preço Unitário (PU) calculado para liquidação em D0.
+        - BidRate: Taxa de compra para liquidação em D0 (decimal).
+        - AskRate: Taxa de venda para liquidação em D0 (decimal).
+        - IndicativeRate: Taxa indicativa para liquidação em D0 (decimal).
 
     Notes:
         A fonte dos dados segue a seguinte hierarquia:
 
-        1.  **Cache Local (Padrão):** Fornece acesso rápido a dados históricos
-            desde 01/01/2020. É utilizado por padrão (`fetch_from_source=False`).
-        2.  **Site Público da ANBIMA:** Acessado quando `fetch_from_source=True`,
-            disponibiliza os dados dos últimos 5 dias úteis.
-        3.  **Rede RTM da ANBIMA:** Acessada quando `fetch_from_source=True` para
-            datas com mais de 5 dias úteis. O acesso ao histórico completo
-            requer uma conexão à rede RTM. Sem ela, a consulta para datas
-            antigas retornará um DataFrame vazio.
+        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`.
     """
-    if any_is_empty(date):
-        return pl.DataFrame()
     date = converter_datas(date)
 
-    if not bday.is_business_day(date):
-        return pl.DataFrame()
-
-    if date > clock.today():
+    if not data_referencia_valida(date):
         return pl.DataFrame()
 
-    if fetch_from_source:
-        # Tenta buscar os dados diretamente da fonte (ANBIMA)
+    # Cache primeiro; se não tiver, busca na fonte
+    df = obter_dataset_cacheado("tpf")
+    if not df.is_empty():
+        df = df.filter(pl.col("ReferenceDate") == date)
+    if df.is_empty():
         df = _buscar_dados_tpf(date)
-    else:
-        # Caso contrário, obtém os dados do cache local
-        df = obter_dataset_cacheado("tpf").filter(pl.col("ReferenceDate") == date)
+    df = _selecionar_e_ordenar_colunas(df)
 
     if df.is_empty():
         return pl.DataFrame()
@@ -416,6 +292,33 @@ def tpf_data(
     return df.sort("ReferenceDate", "BondType", "MaturityDate")
 
 
+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("ReferenceDate", "BondType", "MaturityDate")
+
+
 def tpf_maturities(
     date: DateLike,
     bond_type: BOND_TYPES,
@@ -450,4 +353,4 @@ def tpf_maturities(
             2035-01-01
         ]
     """
-    return tpf_data(date, bond_type)["MaturityDate"].unique().sort()
+    return tpf(date, bond_type)["MaturityDate"].unique().sort()

{pyield-0.45.0 → pyield-0.45.2}/pyield/b3/futures/historical.py

@@ -149,11 +149,14 @@ def listar_datas_disponiveis(codigo_contrato: str) -> pl.Series:
 def _buscar_price_report(
     data: dt.date, codigo: str, full_report: bool | None
 ) -> pl.DataFrame:
-    """Busca o price report da B3, com fallback SPR→PR quando full_report=None."""
-    if full_report is not None:
-        return fetch_price_report(
-            date=data, contract_code=codigo, full_report=full_report
-        )
+    """Busca o price report da B3, com fallback SPR→PR.
+
+    Quando full_report é True, usa apenas o PR (completo).
+    Nos demais casos (None ou False), tenta o SPR (leve) primeiro
+    e faz fallback para o PR se o SPR estiver vazio.
+    """
+    if full_report is True:
+        return fetch_price_report(date=data, contract_code=codigo, full_report=True)
 
     # SPR (leve) primeiro; PR (pesado) como fallback
     df = fetch_price_report(date=data, contract_code=codigo, full_report=False)

{pyield-0.45.0 → pyield-0.45.2}/pyield/b3/intraday_derivatives.py

@@ -50,7 +50,7 @@ def _mapa_renomeacao_intraday() -> dict[str, str]:
     return {nome_orig: nome_novo for nome_orig, nome_novo, _ in COLUNAS_INTRADAY}
 
 
-@ttl_cache(ttl=15)
+@ttl_cache(ttl=10)
 @retry_padrao
 def _buscar_json_intraday(codigo_contrato: str) -> list[dict]:
     url = f"{URL_BASE_INTRADAY}/{codigo_contrato}"

{pyield-0.45.0 → pyield-0.45.2}/pyield/bc/ptax_api.py

@@ -54,7 +54,7 @@ def _montar_url_api(inicio: dt.date, fim: dt.date) -> str:
     return url
 
 
-@ttl_cache(ttl=15)
+@ttl_cache()
 @retry_padrao
 def _buscar_texto_api(url: str) -> bytes:
     resposta = requests.get(url, timeout=10)

{pyield-0.45.0 → pyield-0.45.2}/pyield/bc/rates.py

@@ -43,7 +43,7 @@ class SerieBC(Enum):
     DI_OVER = 11
 
 
-@ttl_cache(ttl=15)
+@ttl_cache()
 @retry_padrao
 def _chamar_api(url_api: str) -> list[dict[str, str]]:
     """Executa uma chamada GET na API do BCB e retorna o JSON.

{pyield-0.45.0 → pyield-0.45.2}/pyield/bc/trades_intraday.py

@@ -94,7 +94,7 @@ ORDEM_COLUNAS_FINAL = [
 ]
 
 
-@ttl_cache(ttl=15)
+@ttl_cache()
 @retry_padrao
 def _buscar_csv() -> str:
     """

{pyield-0.45.0 → pyield-0.45.2}/pyield/bc/vna.py

@@ -10,7 +10,7 @@ from pyield._internal.types import DateLike, any_is_empty
 logger = logging.getLogger(__name__)
 
 
-@ttl_cache(ttl=15)
+@ttl_cache()
 @retry_padrao
 def _baixar_texto(date: DateLike) -> str:
     """Baixa o arquivo diário do SELIC no site do BCB."""