PYield 0.45.2__tar.gz → 0.46.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyield
-Version: 0.45.2
+Version: 0.46.0
 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
@@ -39,9 +39,7 @@ Requires-Python: >=3.12
 Requires-Dist: fastexcel>=0.19.0
 Requires-Dist: lxml>=6.0.0
 Requires-Dist: polars>=1.39.0
-Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: requests>=2.31.0
-Requires-Dist: tenacity>=9.0.0
 Description-Content-Type: text/markdown
 
 [![PyPI version](https://img.shields.io/pypi/v/pyield.svg)](https://pypi.python.org/pypi/pyield)

pyield-0.46.0/pyield/__about__.py

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

pyield-0.46.0/pyield/_internal/br_numbers.py

@@ -0,0 +1,40 @@
+import polars as pl
+
+
+def float_br(coluna: str) -> pl.Expr:
+    """Converte coluna string no formato numérico brasileiro para Float64.
+
+    Remove separadores de milhar (.) e troca vírgula decimal (,) por ponto.
+    """
+    return (
+        pl.col(coluna)
+        .str.strip_chars()
+        .str.replace_all(".", "", literal=True)
+        .str.replace(",", ".", literal=True)
+        .cast(pl.Float64)
+    )
+
+
+def taxa_br(coluna: str, casas_pct: int = 4) -> pl.Expr:
+    """Converte taxa percentual BR (string) para decimal Float64.
+
+    Args:
+        coluna: Nome da coluna com taxa em formato BR (ex.: "12,3456").
+        casas_pct: Casas decimais da taxa percentual de entrada. Default 4,
+            padrão do mercado brasileiro de renda fixa.
+    """
+    return (float_br(coluna) / 100).round(casas_pct + 2)
+
+
+def inteiro_br(coluna: str) -> pl.Expr:
+    """Converte coluna string no formato numérico brasileiro para inteiro.
+
+    Remove separadores de milhar (.) e troca vírgula decimal (,) por ponto,
+    depois converte para Int64.
+    """
+    return float_br(coluna).round(0).cast(pl.Int64)
+
+
+def inteiro_m(coluna: str) -> pl.Expr:
+    """Converte coluna numérica BR em milhares para inteiro (unidades)."""
+    return (float_br(coluna) * 1000).round(0).cast(pl.Int64)

pyield-0.46.0/pyield/_internal/retry.py

@@ -0,0 +1,98 @@
+import functools
+import logging
+import random
+import time
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar
+
+from requests import exceptions as rex
+
+registro = logging.getLogger(__name__)
+
+# Constantes para valores de retry
+_TAMANHO_MAXIMO_EXCECAO = 150
+_HTTP_MUITAS_REQUISICOES = 429
+_HTTP_ERRO_SERVIDOR_MINIMO = 500
+_MAX_TENTATIVAS = 3
+_ESPERA_MINIMA = 1.0
+_ESPERA_MAXIMA = 10.0
+_MULTIPLICADOR_BACKOFF = 2.0
+
+_EXCECOES_TRANSITORIAS = (
+    rex.Timeout,
+    rex.ConnectionError,
+    rex.SSLError,
+    rex.ChunkedEncodingError,
+)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def _logar_antes_espera(
+    tentativa: int, excecao: Exception, tempo_espera: float
+) -> None:
+    """Loga uma mensagem antes da espera entre tentativas."""
+    texto_excecao = str(excecao).replace("\n", " ")
+    texto_excecao_truncado = texto_excecao[:_TAMANHO_MAXIMO_EXCECAO]
+    if len(texto_excecao) > _TAMANHO_MAXIMO_EXCECAO:
+        texto_excecao_truncado += "..."
+
+    registro.warning(
+        "Tentativa %s falhou com %s: %s Tentando novamente em %.2f segundos...",
+        tentativa,
+        type(excecao).__name__,
+        texto_excecao_truncado,
+        tempo_espera,
+    )
+
+
+def _deve_tentar_novamente_por_excecao(excecao: Exception) -> bool:
+    """Determina se uma exceção capturada justifica uma nova tentativa."""
+    # Erros de rede genéricos são sempre transitórios
+    if isinstance(excecao, _EXCECOES_TRANSITORIAS):
+        return True
+
+    # HTTPError: apenas 429 e 5xx são transitórios
+    if isinstance(excecao, rex.HTTPError) and excecao.response is not None:
+        codigo_status = excecao.response.status_code
+        return (
+            codigo_status == _HTTP_MUITAS_REQUISICOES
+            or codigo_status >= _HTTP_ERRO_SERVIDOR_MINIMO
+        )
+
+    return False
+
+
+def _calcular_tempo_espera(tentativa: int) -> float:
+    """Calcula o tempo de espera com backoff exponencial e jitter."""
+    limite_superior = min(
+        _ESPERA_MAXIMA,
+        max(_ESPERA_MINIMA, _MULTIPLICADOR_BACKOFF * (2 ** (tentativa - 1))),
+    )
+    return random.uniform(_ESPERA_MINIMA, limite_superior)
+
+
+def retry_padrao(func: Callable[P, R]) -> Callable[P, R]:
+    """Aplica retry com backoff exponencial e jitter para falhas transitórias."""
+
+    @functools.wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        for tentativa in range(1, _MAX_TENTATIVAS + 1):
+            try:
+                return func(*args, **kwargs)
+            except Exception as excecao:
+                if (
+                    tentativa == _MAX_TENTATIVAS
+                    or not _deve_tentar_novamente_por_excecao(excecao)
+                ):
+                    raise
+
+                tempo_espera = _calcular_tempo_espera(tentativa)
+                _logar_antes_espera(tentativa, excecao, tempo_espera)
+                time.sleep(tempo_espera)
+
+        msg = "Fluxo de retry inválido: laço encerrado sem retorno nem exceção."
+        raise RuntimeError(msg)
+
+    return wrapper

{pyield-0.45.2 → pyield-0.46.0}/pyield/anbima/difusao.py

@@ -2,11 +2,12 @@ import datetime as dt
 import logging
 
 import polars as pl
-import polars.selectors as cs
 import requests
 
 import pyield._internal.converters as cv
 from pyield import bday
+from pyield._internal.br_numbers import taxa_br
+from pyield._internal.cache import ttl_cache
 from pyield._internal.types import DateLike, any_is_empty
 
 VERSAO_API = "1.0018"
@@ -18,51 +19,11 @@ URL_PAGINA_INICIAL = f"{URL_BASE}/taxasOnline.asp"
 URL_CONSULTA_DADOS = f"{URL_BASE}/exibedados.asp"
 URL_DOWNLOAD = f"{URL_BASE}/download_dados.asp?extensao=csv"
 
-MAPA_COLUNAS = [
-    ("Título", "titulo", pl.String),
-    ("Vencimento", "data_vencimento", pl.String),
-    ("Código ISIN", "codigo_isin", pl.String),
-    ("Provedor", "provedor", pl.String),
-    ("Edital", "edital", pl.String),
-    ("Horário", "horario", pl.String),
-    ("Prazo", "prazo", pl.Int64),
-    ("Lote", "lote", pl.String),
-    ("Fech D-1", "taxa_indicativa_anterior", pl.Float64),
-    ("Indicativo Superior", "taxa_limite_superior", pl.Float64),
-    ("Máxima", "taxa_maxima", pl.Float64),
-    ("Média", "taxa_media", pl.Float64),
-    ("Mínima", "taxa_minima", pl.Float64),
-    ("Indicativo Inferior", "taxa_limite_inferior", pl.Float64),
-    ("Última", "taxa_ultima", pl.Float64),
-    ("Oferta Compra", "taxa_compra", pl.Float64),
-    ("Oferta Venda", "taxa_venda", pl.Float64),
-    ("Nº de Negócios", "num_negocios", pl.Int64),
-    ("Quantidade Negociada", "quantidade_negociada", pl.Int64),
-    ("Volume Negociado (R$)", "volume_negociado", pl.Float64),
-]
-
-ESQUEMA_API = {csv: tipo for csv, _, tipo in MAPA_COLUNAS}
-ALIAS_COLUNAS = {csv: novo for csv, novo, _ in MAPA_COLUNAS}
-
-# Colunas não selecionadas estão vazias na API.
-ORDEM_COLUNAS_FINAL = [
-    "data_hora_referencia",
-    "provedor",
-    "titulo",
-    "data_vencimento",
-    "codigo_isin",
-    "dias_uteis",
-    "taxa_indicativa_anterior",
-    "taxa_venda",
-    "taxa_compra",
-    "taxa_media",
-    "taxa_ultima",
-]
-
 logger = logging.getLogger(__name__)
 
 
-def _buscar_dados_url(data_referencia: str) -> str:
+@ttl_cache()
+def _buscar_dados_url(data_referencia: str) -> bytes:
     cabecalhos = {
         "Referer": URL_PAGINA_INICIAL,
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",  # noqa
@@ -115,72 +76,52 @@ def _buscar_dados_url(data_referencia: str) -> str:
                     f"{data_referencia}."
                 )
             response_download.encoding = "iso-8859-1"
-            return response_download.text
+            return response_download.text.encode("utf-8")
         except requests.exceptions.RequestException as e:
             logger.error(f"Erro ao buscar dados para a data '{data_referencia}': {e}")
             raise
 
 
-def _extrair_data_referencia_e_csv_limpo(csv_data: str) -> tuple[dt.date, bytes]:
-    """Extrai a data de referência do CSV e devolve o conteúdo pronto para leitura."""
-    linhas_csv = csv_data.strip().splitlines()
-    if not linhas_csv:
-        raise ValueError("CSV vazio ou inválido.")
-
-    if ":" not in linhas_csv[0]:
-        raise ValueError("Cabeçalho do CSV inválido: data de referência ausente.")
-
-    data_ref_str = linhas_csv[0].split(":")[1].strip()
-    data_ref = dt.datetime.strptime(data_ref_str, "%d/%m/%Y").date()
-
-    # O CSV da Anbima contém ';' extra no fim do cabeçalho.
-    # Remove apenas esse caractere para garantir a leitura correta.
-    csv_limpo = (
-        "\n".join(linhas_csv[1:])
-        .replace("Volume Negociado (R$);", "Volume Negociado (R$)")
-        .encode()
-    )
+def _ler_csv_bruto(csv_bruto: bytes) -> pl.DataFrame:
+    """Lê o CSV bruto da Anbima e devolve DataFrame com todas as colunas string."""
+    return pl.read_csv(
+        csv_bruto,
+        separator=";",
+        infer_schema=False,
+        skip_rows=1,
+    ).with_columns(pl.all().str.strip_chars())
 
-    return data_ref, csv_limpo
 
+def _processar_csv(data_ref: dt.date, df: pl.DataFrame) -> pl.DataFrame:
+    """Converte o DataFrame bruto em DataFrame Polars estruturado."""
 
-def _processar_csv(data_ref: dt.date, csv_limpo: bytes) -> pl.DataFrame:
-    """Converte o CSV limpo em um DataFrame Polars estruturado."""
-    df = (
-        pl.read_csv(
-            csv_limpo,
-            separator=";",
-            decimal_comma=True,
-            schema=ESQUEMA_API,
-        )
-        .rename(ALIAS_COLUNAS)
-        .with_columns(cs.string().str.strip_chars())  # Remove espaços em branco
-        .with_columns(
-            pl.col("data_vencimento").str.to_date(format="%d/%m/%Y"),
-            data_referencia=data_ref,  # Adiciona a coluna de data de referência
-            # Ajusta o horário para 12:00:00 quando o provedor for "ANBIMA 12H"
-            horario=pl.when(pl.col("provedor") == "ANBIMA 12H")
+    return (
+        df.with_columns(
+            data_vencimento=pl.col("Vencimento").str.to_date(format="%d/%m/%Y"),
+            horario=pl.when(pl.col("Provedor") == "ANBIMA 12H")
             .then(dt.time(12, 0))
-            .otherwise(pl.col("horario").str.to_time(format="%H:%M:%S")),
-            taxa_media=pl.mean_horizontal("taxa_compra", "taxa_venda"),
+            .otherwise(pl.col("Horário").str.to_time(format="%H:%M:%S")),
+            taxa_venda=taxa_br("Oferta Venda"),
+            taxa_compra=taxa_br("Oferta Compra"),
         )
-        .with_columns(
-            bday.count_expr("data_referencia", "data_vencimento").alias("dias_uteis"),
-            # Converte as colunas de taxa de percentual para decimal
-            # São 6 casas decimais no máximo.
-            # Arredondar na 8a para minimizar erros de ponto flutuante.
-            cs.starts_with("taxa_").truediv(100).round(8),
-            pl.col("data_referencia")
-            .dt.combine(pl.col("horario"))
-            .dt.replace_time_zone("America/Sao_Paulo")
-            .alias("data_hora_referencia"),
+        .select(
+            data_hora_referencia=pl.lit(data_ref).dt.combine(pl.col("horario")),
+            provedor=pl.col("Provedor"),
+            titulo=pl.col("Título"),
+            data_vencimento=pl.col("data_vencimento"),
+            codigo_isin=pl.col("Código ISIN"),
+            dias_uteis=bday.count_expr(data_ref, "data_vencimento"),
+            taxa_indicativa_anterior=taxa_br("Fech D-1"),
+            taxa_indicativa_superior=taxa_br("Indicativo Superior"),
+            taxa_indicativa_inferior=taxa_br("Indicativo Inferior"),
+            taxa_venda=pl.col("taxa_venda"),
+            taxa_compra=pl.col("taxa_compra"),
+            taxa_media=pl.mean_horizontal("taxa_compra", "taxa_venda"),
+            taxa_ultima=taxa_br("Última"),
         )
-        .select(ORDEM_COLUNAS_FINAL)
         .sort("titulo", "data_vencimento", "data_hora_referencia")
     )
 
-    return df
-
 
 def tpf_difusao(data_referencia: DateLike) -> pl.DataFrame:
     """
@@ -197,14 +138,15 @@ def tpf_difusao(data_referencia: DateLike) -> pl.DataFrame:
         ValueError: Em resposta inválida da API ou erro de parsing do CSV.
 
     Output Columns:
-        - data_hora_referencia (datetime[America/Sao_Paulo]): Data e hora de
-            referência da taxa no fuso horário de São Paulo.
+        - data_hora_referencia (Datetime): Data e hora de referência da taxa.
         - provedor (string): Provedor dos dados.
         - titulo (string): Nome do título (ex: LFT, LTN).
         - data_vencimento (date): Data de vencimento do título.
         - codigo_isin (string): Código ISIN do título.
         - dias_uteis (int): Dias úteis entre a data de referência e o vencimento.
         - taxa_indicativa_anterior (float): Taxa indicativa de fechamento D-1 (decimal).
+        - taxa_indicativa_superior (float): Limite superior da banda indicativa (decimal).
+        - taxa_indicativa_inferior (float): Limite inferior da banda indicativa (decimal).
         - taxa_venda (float): Taxa de oferta de venda (Ask rate) (decimal).
         - taxa_compra (float): Taxa de oferta de compra (Bid rate) (decimal).
         - taxa_media (float): Média entre a taxa de compra e venda (decimal).
@@ -216,7 +158,6 @@ def tpf_difusao(data_referencia: DateLike) -> pl.DataFrame:
     if not bday.is_business_day(data):
         return pl.DataFrame()
     data_str = data.strftime("%d/%m/%Y")
-    csv_data = _buscar_dados_url(data_str)
-
-    data_ref, csv_limpo = _extrair_data_referencia_e_csv_limpo(csv_data)
-    return _processar_csv(data_ref, csv_limpo)
+    csv_bruto = _buscar_dados_url(data_str)
+    df = _ler_csv_bruto(csv_bruto)
+    return _processar_csv(data, df)

pyield-0.46.0/pyield/anbima/ettj_intraday.py

@@ -0,0 +1,83 @@
+import datetime as dt
+
+import polars as pl
+import requests
+
+from pyield._internal.br_numbers import float_br, taxa_br
+from pyield._internal.cache import ttl_cache
+from pyield._internal.retry import retry_padrao
+
+URL_ETTJ_INTRADAY = (
+    "https://www.anbima.com.br/informacoes/curvas-intradiarias/cIntra-down.asp"
+)
+
+# Dados ETTJ: taxas com 4 casas decimais em percentual (ex.: 14,2644%).
+
+
+@ttl_cache()
+@retry_padrao
+def _buscar_texto_intraday() -> str:
+    carga_requisicao = {"Dt_Ref": "", "saida": "csv"}
+    resposta = requests.post(URL_ETTJ_INTRADAY, data=carga_requisicao, timeout=10)
+    resposta.raise_for_status()
+    resposta.encoding = "latin1"
+    return resposta.text
+
+
+def _extrair_data_e_tabelas(texto: str) -> tuple[dt.date, str, str]:
+    """Separa o texto bruto em data de referência e as duas tabelas CSV."""
+    # Cada seção (PREFIXADOS e IPCA) é separada por linha em branco
+    secao_pre, secao_ipca = texto.strip().replace("\r\n", "\n").split("\n\n")
+
+    # Estrutura de cada seção: título, data, header+dados
+    linhas_pre = secao_pre.splitlines()
+    data_ref = dt.datetime.strptime(linhas_pre[1], "%d/%m/%Y").date()
+    tabela_pre = "\n".join(linhas_pre[2:])
+
+    linhas_ipca = secao_ipca.splitlines()
+    tabela_ipca = "\n".join(linhas_ipca[2:])
+
+    return data_ref, tabela_pre, tabela_ipca
+
+
+def _parsear_tabela_intraday(texto: str, nome_taxa: str) -> pl.DataFrame:
+    return pl.read_csv(texto.encode(), separator=";", infer_schema=False).select(
+        vertice=float_br("Vertices").cast(pl.Int64),
+        **{nome_taxa: taxa_br("D0")},
+    )
+
+
+def intraday_ettj() -> pl.DataFrame:
+    """Obtém e processa a curva de juros intradiária da ANBIMA.
+
+    Busca os dados mais recentes da curva de juros intradiária publicada pela
+    ANBIMA, contendo taxas reais (indexadas ao IPCA), taxas nominais e inflação
+    implícita em diversos vértices. A curva é publicada por volta das 12h30 BRT.
+
+    Returns:
+        pl.DataFrame: DataFrame com os dados intradiários da ETTJ.
+
+    Output Columns:
+        - data_referencia (Date): data de referência da curva de juros.
+        - vertice (Int64): vértice em dias úteis.
+        - taxa_nominal (Float64): taxa de juros nominal zero-cupom.
+        - taxa_real (Float64): taxa de juros real zero-cupom (indexada ao IPCA).
+        - inflacao_implicita (Float64): taxa de inflação implícita (breakeven).
+
+    Notes:
+        Todas as taxas são expressas em formato decimal (ex: 0.12 para 12%).
+    """
+    texto_api = _buscar_texto_intraday()
+
+    data_ref, tabela_pre, tabela_ipca = _extrair_data_e_tabelas(texto_api)
+
+    df_pre = _parsear_tabela_intraday(tabela_pre, "taxa_nominal")
+    df_ipca = _parsear_tabela_intraday(tabela_ipca, "taxa_real")
+    expr_inflacao_impl = (pl.col("taxa_nominal") + 1) / (pl.col("taxa_real") + 1) - 1
+    df = df_pre.join(df_ipca, on="vertice", how="right").with_columns(
+        data_referencia=data_ref,
+        inflacao_implicita=expr_inflacao_impl.round(6),
+    )
+    return df.select(
+        "data_referencia", "vertice", "taxa_nominal", "taxa_real", "inflacao_implicita"
+    )

pyield-0.46.0/pyield/anbima/ettj_last.py

@@ -0,0 +1,76 @@
+import datetime as dt
+
+import polars as pl
+import requests
+
+from pyield._internal.br_numbers import float_br, taxa_br
+from pyield._internal.cache import ttl_cache
+from pyield._internal.retry import retry_padrao
+
+URL_ULTIMA_ETTJ = "https://www.anbima.com.br/informacoes/est-termo/CZ-down.asp"
+
+# Dados ETTJ: taxas com 4 casas decimais em percentual (ex.: 14,2644%).
+
+
+@ttl_cache()
+@retry_padrao
+def _buscar_texto_ultima_ettj() -> str:
+    """Busca o texto bruto da curva de juros na ANBIMA."""
+    carga_requisicao = {
+        "Idioma": "PT",
+        "Dt_Ref": "",
+        "saida": "csv",
+    }
+    resposta = requests.post(URL_ULTIMA_ETTJ, data=carga_requisicao, timeout=10)
+    resposta.raise_for_status()
+    resposta.encoding = "latin1"
+    return resposta.text
+
+
+def _extrair_data_e_tabela(texto: str) -> tuple[dt.date, str]:
+    """Separa o texto bruto em data de referência e a tabela CSV principal."""
+    # Seções separadas por linha em branco: betas, ETTJ, circular, erros
+    secoes = texto.strip().replace("\r\n", "\n").split("\n\n")
+    # A data está na primeira linha da primeira seção (ex.: "20/03/2026;Beta 1;...")
+    data_str = secoes[0].splitlines()[0][:10]
+    data_ref = dt.datetime.strptime(data_str, "%d/%m/%Y").date()
+    # A tabela ETTJ é a segunda seção; pular o título (primeira linha)
+    linhas_ettj = secoes[1].splitlines()
+    tabela = "\n".join(linhas_ettj[1:])
+    return data_ref, tabela
+
+
+def _processar_tabela(texto: str, data_referencia: dt.date) -> pl.DataFrame:
+    """Lê o CSV e converte para DataFrame com taxas decimais."""
+    return pl.read_csv(texto.encode(), separator=";", infer_schema=False).select(
+        data_referencia=data_referencia,
+        vertice=float_br("Vertices").cast(pl.Int64),
+        taxa_nominal=taxa_br("ETTJ PREF"),
+        taxa_real=taxa_br("ETTJ IPCA"),
+        inflacao_implicita=taxa_br("Inflação Implícita"),
+    )
+
+
+def last_ettj() -> pl.DataFrame:
+    """Obtém e processa a última curva de juros (ETTJ) publicada pela ANBIMA.
+
+    Busca os dados mais recentes da curva de juros de fechamento publicada pela
+    ANBIMA, contendo taxas reais (indexadas ao IPCA), taxas nominais e inflação
+    implícita em diversos vértices.
+
+    Returns:
+        pl.DataFrame: DataFrame com os dados da ETTJ de fechamento.
+
+    Output Columns:
+        - data_referencia (Date): data de referência da curva de juros.
+        - vertice (Int64): vértice em dias úteis.
+        - taxa_nominal (Float64): taxa de juros nominal zero-cupom.
+        - taxa_real (Float64): taxa de juros real zero-cupom (indexada ao IPCA).
+        - inflacao_implicita (Float64): taxa de inflação implícita (breakeven).
+
+    Notes:
+        Todas as taxas são expressas em formato decimal (ex: 0.12 para 12%).
+    """
+    texto = _buscar_texto_ultima_ettj()
+    data_ref, tabela = _extrair_data_e_tabela(texto)
+    return _processar_tabela(tabela, data_ref)

pyield-0.46.0/pyield/anbima/ima.py

@@ -0,0 +1,129 @@
+from typing import Literal
+
+import polars as pl
+import requests
+
+from pyield._internal.br_numbers import float_br, inteiro_m, taxa_br
+from pyield._internal.cache import ttl_cache
+from pyield._internal.retry import retry_padrao
+
+TiposIMA = Literal[
+    "IRF-M 1",
+    "IRF-M 1+",
+    "IRF-M",
+    "IMA-B 5",
+    "IMA-B 5+",
+    "IMA-B",
+    "IMA-S",
+    "IMA-GERAL-EX-C",
+    "IMA-GERAL",
+]
+
+
+URL_ULTIMO_IMA = "https://www.anbima.com.br/informacoes/ima/arqs/ima_completo.txt"
+
+
+@ttl_cache()
+@retry_padrao
+def _buscar_texto_ultimo_ima() -> str:
+    resposta = requests.get(URL_ULTIMO_IMA, timeout=3)
+    resposta.raise_for_status()
+    resposta.encoding = "latin1"
+    return resposta.text
+
+
+def _parsear_df(texto: str) -> pl.DataFrame:
+    texto_csv = texto.split("2@COMPOSIÇÃO DE CARTEIRA")[1].strip()
+    return pl.read_csv(
+        texto_csv.encode(),
+        separator="@",
+        infer_schema=False,
+        null_values="--",
+    )
+
+
+def _processar_df(df: pl.DataFrame) -> pl.DataFrame:
+    mduration_expr = pl.col("duration") / (1 + pl.col("taxa_indicativa"))
+    dv01_mercado_expr = pl.col("dv01") * pl.col("quantidade_mercado")
+    df = (
+        df.with_columns(
+            pu=float_br("PU (R$)"),
+            duration=pl.col("Duration (d.u.)").cast(pl.Int64).truediv(252),
+            taxa_indicativa=taxa_br("Taxa Indicativa (% a.a.)", 4),
+            quantidade_mercado=inteiro_m("Quantidade (1.000 títulos)"),
+        )
+        .with_columns(dv01=0.0001 * pl.col("pu") * mduration_expr)
+        .select(
+            data_referencia=pl.col("Data de Referência").str.to_date("%d/%m/%Y"),
+            indice=pl.col("INDICE"),
+            titulo=pl.col("Títulos"),
+            data_vencimento=pl.col("Data de Vencimento").str.to_date("%d/%m/%Y"),
+            codigo_selic=pl.col("Código SELIC").cast(pl.Int64),
+            codigo_isin=pl.col("Código ISIN"),
+            dias_uteis=pl.col("Prazo (d.u.)").cast(pl.Int64),
+            duration=pl.col("duration"),
+            taxa_indicativa=pl.col("taxa_indicativa"),
+            pu=pl.col("pu"),
+            pu_juros=float_br("PU de Juros (R$)"),
+            dv01=pl.col("dv01"),
+            pmr=float_br("PMR"),
+            peso=float_br("Peso (%)"),
+            convexidade=float_br("Convexidade"),
+            quantidade_teorica=float_br("Quantidade Teórica (1.000 títulos)"),
+            operacoes=pl.col("Número de Operações *").cast(pl.Int64),
+            quantidade_negociada=inteiro_m("Quant. Negociada (1.000 títulos) *"),
+            valor_negociado=inteiro_m("Valor Negociado (R$ mil) *"),
+            dv01_mercado=dv01_mercado_expr.round(0).cast(pl.Int64),
+            quantidade_mercado=pl.col("quantidade_mercado"),
+            valor_mercado=inteiro_m("Carteira a Mercado (R$ mil)"),
+        )
+    )
+    return df
+
+
+def last_ima(ima_type: TiposIMA | None = None) -> pl.DataFrame:
+    """Obtém os últimos dados de composição de carteira IMA disponíveis na ANBIMA.
+
+    Busca e processa os dados do arquivo IMA completo publicado pela ANBIMA,
+    retornando um DataFrame estruturado.
+
+    Args:
+        ima_type (str, optional): Tipo de índice IMA para filtrar os dados.
+            Se None, retorna todos os índices. Padrão é None.
+
+    Returns:
+        pl.DataFrame: DataFrame com os dados do IMA.
+
+    Output Columns:
+        - data_referencia (Date): data de referência.
+        - indice (String): índice IMA (ex: 'IMA-B', 'IRF-M').
+        - titulo (String): título (ex: 'LTN', 'NTN-B').
+        - data_vencimento (Date): data de vencimento do título.
+        - codigo_selic (Int64): código do título no sistema SELIC.
+        - codigo_isin (String): código ISIN.
+        - dias_uteis (Int64): dias úteis até o vencimento.
+        - duration (Float64): duration do título em anos úteis (252 d.u./ano).
+        - taxa_indicativa (Float64): taxa indicativa em decimal (ex: 0.10 para 10%).
+        - pu (Float64): preço unitário (PU) em R$.
+        - pu_juros (Float64): PU de juros em R$.
+        - dv01 (Float64): DV01 em R$.
+        - pmr (Float64): prazo médio de repactuação.
+        - peso (Float64): peso do título no índice (%).
+        - convexidade (Float64): convexidade do título.
+        - quantidade_teorica (Float64): quantidade teórica (em 1.000 títulos).
+        - operacoes (Int64): número de operações.
+        - quantidade_negociada (Int64): quantidade negociada (unidades).
+        - valor_negociado (Int64): valor negociado em R$.
+        - dv01_mercado (Int64): DV01 de mercado em R$.
+        - quantidade_mercado (Int64): quantidade em carteira (unidades).
+        - valor_mercado (Int64): valor de mercado em R$.
+
+    Examples:
+        >>> yd.anbima.last_ima("IMA-B")  # doctest: +SKIP
+    """
+    texto_ima = _buscar_texto_ultimo_ima()
+    df = _parsear_df(texto_ima)
+    df = _processar_df(df)
+    if ima_type:
+        df = df.filter(pl.col("indice") == ima_type)
+    return df.sort("indice", "titulo", "data_vencimento")