PYield 0.26.7__tar.gz → 0.27.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.26.7
+Version: 0.27.0
 Summary: A Python library for analysis of fixed income instruments in Brazil
 Project-URL: Source, https://github.com/crdcj/PYield
 Author-email: Carlos Carvalho <cr.cj@outlook.com>

pyield-0.27.0/pyield/__about__.py

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

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

@@ -1,9 +1,11 @@
-from pyield import anbima, bday
+from pyield import bday
 from pyield.__about__ import __version__
+from pyield.anbima.ima import ima
+from pyield.anbima.imaq import imaq
+from pyield.anbima.tpf import anbima_tpf_data, anbima_tpf_rates, tpf_pre_maturities
 from pyield.b3_futures import futures
 from pyield.b3_futures.di import DIFutures
 from pyield.bc.auction import auctions
-from pyield.ima import ima
 from pyield.indicators import indicator
 from pyield.interpolator import Interpolator
 from pyield.projections import projection
@@ -12,13 +14,16 @@ from pyield.tpf import lft, ltn, ntnb, ntnf
 
 __all__ = [
     "__version__",
-    "anbima",
+    "anbima_tpf_data",
+    "anbima_tpf_rates",
+    "tpf_pre_maturities",
     "auctions",
     "bday",
     "DIFutures",
     "forward_rates",
     "futures",
     "ima",
+    "imaq",
     "indicator",
     "Interpolator",
     "lft",

{pyield-0.26.7/pyield → pyield-0.27.0/pyield/anbima}/ima.py

@@ -69,14 +69,14 @@ def _process_last_ima(df: pd.DataFrame) -> pd.DataFrame:
     df["Date"] = pd.to_datetime(df["Date"], format="%d/%m/%Y")
     df["Maturity"] = pd.to_datetime(df["Maturity"], format="%d/%m/%Y")
     df["MarketQuantity"] = (1000 * df["MarketQuantity"]).astype("Int64")
+    df["MarketValue"] = (1000 * df["MarketValue"]).round(0).astype("Int64")
     df["Price"] = df["Price"].round(6)
     # Duration is in business days, convert to years
     df["Duration"] /= 252
     mduration = df["Duration"] / (1 + df["IndicativeRate"])
-    dv01 = 0.0001 * df["Price"] * mduration * df["MarketQuantity"]
-    # Since DV01 and MarketValue are total stock values, we round them to integers
-    df["MarketDV01"] = dv01.round(0).astype("Int64")
-    df["MarketValue"] = (1000 * df["MarketValue"]).round(0).astype("Int64")
+    df["DV01"] = 0.0001 * df["Price"] * mduration * df["MarketQuantity"]
+    # Since MarketDV01 is the total stock value, we round them to integer
+    df["MarketDV01"] = df["DV01"].round(0).astype("Int64")
     # LFT DV01 is zero
     df["MarketDV01"] = df["MarketDV01"].where(df["BondType"] != "LFT", 0)
     return df
@@ -95,6 +95,7 @@ def _reorder_last_ima(df: pd.DataFrame) -> pd.DataFrame:
         "Price",
         "BDToMat",
         "Duration",
+        "DV01",
         "PMR",
         "Convexity",
         "TheoreticalQuantity",

pyield-0.27.0/pyield/anbima/imaq.py

@@ -0,0 +1,142 @@
+import io
+import logging
+import re
+import warnings
+
+import pandas as pd
+import requests
+from bs4 import XMLParsedAsHTMLWarning
+
+from pyield import date_converter as dc
+from pyield.date_converter import DateScalar
+
+IMA_URL = "https://www.anbima.com.br/informacoes/ima/ima-quantidade-mercado.asp"
+COLUMN_MAPPING = {
+    "Data Referência": "Date",
+    "Título": "BondType",
+    "Data de Vencimento": "Maturity",
+    "Codigo Selic": "SelicCode",
+    "Código ISIN": "ISIN",
+    "PU (R$)": "Price",
+    "Quantidade em Mercado (1.000 Títulos)": "MarketQuantity",
+    "Valor de Mercado (R$ Mil)": "MarketValue",
+    "Variação da Quantidade (1.000 Títulos)": "QuantityVariation",
+    "Status do Titulo": "BondStatus",
+}
+
+
+def _fetch_url_tables(target_date: pd.Timestamp) -> pd.DataFrame:
+    # Warning supression for BeautifulSoup, as the text is valid HTML and not XML
+    warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)
+
+    target_date_str = target_date.strftime("%d/%m/%Y")
+    payload = {
+        "Tipo": "",
+        "DataRef": "",
+        "Pai": "ima",
+        "Dt_Ref_Ver": "20250117",
+        "Dt_Ref": f"{target_date_str}",
+    }
+
+    r = requests.post(IMA_URL, data=payload, timeout=10)
+    r.raise_for_status()
+    r.encoding = "iso-8859-1"
+    if "Não há dados disponíveis" in r.text:
+        logging.warning("No data found. Returning empty DataFrame.")
+        return pd.DataFrame()
+
+    string_io_buffer = io.StringIO(r.text)
+
+    dfs = pd.read_html(
+        string_io_buffer,
+        flavor="html5lib",
+        attrs={"width": "100%"},
+        header=0,
+        thousands=".",
+        decimal=",",
+        displayed_only=True,
+        dtype_backend="numpy_nullable",
+    )
+
+    df = (
+        pd.concat(dfs)
+        .query("`Data de Vencimento`.notnull()")
+        .query("Título!='Título'")
+        .drop_duplicates(subset="Código ISIN")
+        .reset_index(drop=True)
+    )
+
+    # Convert to CSV and then back to pandas to get automatic type conversion
+    csv_buffer = io.StringIO(df.to_csv(index=False))
+    df = pd.read_csv(csv_buffer, dtype_backend="numpy_nullable")
+
+    # Expressão regular para datas no formato dd/mm/ano
+    date_pattern = r"\b(\d{2}/\d{2}/\d{4})\b"
+
+    # Busca pela primeira data
+    match = re.search(date_pattern, r.text)
+
+    if match:
+        anbima_date_str = match.group(1)
+        anbima_date = pd.to_datetime(anbima_date_str, format="%d/%m/%Y")
+    else:
+        logging.warning("No date found. Returning empty DataFrame.")
+        return pd.DataFrame()
+
+    df["Data Referência"] = anbima_date
+
+    return df
+
+
+def _process_df(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.rename(columns=COLUMN_MAPPING)[COLUMN_MAPPING.values()]
+    df["Maturity"] = pd.to_datetime(df["Maturity"], format="%d/%m/%Y")
+    # Remove the thousands unit from numeric columns
+    for col in ["MarketQuantity", "MarketValue", "QuantityVariation"]:
+        df[col] = (1000 * df[col]).astype("Int64")
+
+    return df
+
+
+def imaq(date: DateScalar) -> pd.DataFrame:
+    """
+    Fetch and process IMA market data for a given date.
+
+    This function retrieves IMA quantity market data from ANBIMA for a given date,
+    processes the data into a structured DataFrame, and returns the resulting DataFrame.
+    It handles conversion of date formats, renames columns to English, and converts
+    certain numeric columns to integer types. In the event of an error during data
+    fetching or processing, an empty DataFrame is returned.
+
+    Args:
+        date (DateScalar): A date-like object representing the target date for fetching
+            the data.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the IMA data with the following columns:
+            - Date: Reference date of the data.
+            - BondType: Type of bond.
+            - Maturity: Bond maturity date.
+            - SelicCode: Code representing the SELIC rate.
+            - ISIN: International Securities Identification Number.
+            - Price: Bond price.
+            - MarketQuantity: Market quantity (in units of 1000 bonds).
+            - MarketValue: Market value (in units of 1000 reais).
+            - QuantityVariation: Variation in quantity (in units of 1000 bonds).
+            - BondStatus: Status of the bond.
+
+    Raises:
+        Exception: Logs error and returns an empty DataFrame if any error occurs during
+            fetching or processing.
+
+    """
+    try:
+        date = dc.convert_input_dates(date)
+        df = _fetch_url_tables(date)
+        df = _process_df(df)
+        return df
+    except Exception as e:
+        date_str = date.strftime("%d/%m/%Y")
+        logging.error(f"Error fetching IMA for {date_str}. Returning empty DataFrame.")
+        logging.error(f"Error message: {e}", exc_info=True)
+        return pd.DataFrame()

pyield-0.26.7/pyield/anbima.py → pyield-0.27.0/pyield/anbima/tpf.py

@@ -106,7 +106,25 @@ def _process_raw_df(df_raw: pd.DataFrame) -> pd.DataFrame:
     return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)
 
 
-def data(reference_date: DateScalar, bond_type: str | None = None) -> pd.DataFrame:
+def anbima_tpf_data(
+    reference_date: DateScalar, bond_type: str | None = None
+) -> pd.DataFrame:
+    """Fetch and process TPF market data from ANBIMA.
+
+    This function retrieves bond market data from the ANBIMA website for a
+    specified reference date. It handles different file formats based on the date
+    and attempts to download the data from both member and non-member URLs.
+
+    Args:
+        reference_date (DateScalar): The reference date for the data.
+        bond_type (str, optional):  Filter data by bond type.
+            Defaults to None, which returns data for all bond types.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing bond market data.
+            Returns an empty DataFrame if data is not available for the
+            specified date.
+    """
     # Normalize the reference date
     reference_date = dc.convert_input_dates(reference_date)
     file_content = _get_file_content(reference_date)
@@ -125,11 +143,30 @@ def data(reference_date: DateScalar, bond_type: str | None = None) -> pd.DataFra
         return df.reset_index(drop=True)
 
 
-def rates(
+def anbima_tpf_rates(
     reference_date: DateScalar,
     bond_type: str | None = None,
     adj_maturities: bool = False,
 ) -> pd.DataFrame:
+    """Retrieve indicative rates for bonds from ANBIMA data.
+
+    This function fetches indicative interest rates for bonds from ANBIMA,
+    initially attempting to retrieve data from a cached dataset. If the data
+    is not available in the cache, it fetches it directly from the ANBIMA
+    website using the :func:`data` function.
+
+    Args:
+        reference_date (DateScalar): The reference date for the rates.
+        bond_type (str, optional): Filter rates by bond type.
+            Defaults to None, which returns rates for all bond types.
+        adj_maturities (bool, optional): Adjust maturity dates to the next
+            business day. Defaults to False.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing bond types, maturity dates, and
+            indicative rates. Returns an empty DataFrame if data is not
+            available for the specified date.
+    """
     df = get_anbima_dataset()
 
     reference_date = dc.convert_input_dates(reference_date)
@@ -137,7 +174,7 @@ def rates(
 
     if df.empty:
         # Try to fetch the data from the Anbima website
-        df = data(reference_date)
+        df = anbima_tpf_data(reference_date)
 
     if df.empty:
         # If the data is still empty, return an empty DataFrame
@@ -153,11 +190,25 @@ def rates(
     return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)
 
 
-def pre_maturities(reference_date: DateScalar) -> pd.Series:
-    df = get_anbima_dataset()
-    reference_date = dc.convert_input_dates(reference_date)
-    df.query("ReferenceDate == @reference_date", inplace=True)
-    df.query("BondType in ['LTN', 'NTN-F']", inplace=True)
-    maturity_dates = df["MaturityDate"].drop_duplicates()
+def tpf_pre_maturities(reference_date: DateScalar) -> pd.Series:
+    """Retrieve pre-defined maturity dates for LTN and NTN-F bonds.
 
-    return maturity_dates.sort_values(ignore_index=True)
+    This function fetches pre-defined maturity dates for 'LTN' (prefixadas) and
+    'NTN-F' (indexadas ao CDI) bond types from the cached ANBIMA dataset
+    for a given reference date.
+
+    Args:
+        reference_date (DateScalar): The reference date for maturity dates.
+
+    Returns:
+        pd.Series: A Series containing unique maturity dates for 'LTN' and
+            'NTN-F' bonds, sorted in ascending order.
+    """
+    maturity_dates = (
+        anbima_tpf_rates(reference_date)
+        .query("BondType in ['LTN', 'NTN-F']")["MaturityDate"]
+        .drop_duplicates()
+        .sort_values(ignore_index=True)
+        .reset_index(drop=True)
+    )
+    return maturity_dates

pyield-0.27.0/pyield/b3_futures/__init__.py

@@ -0,0 +1,74 @@
+import datetime as dt
+from typing import Literal
+from zoneinfo import ZoneInfo
+
+import pandas as pd
+
+from pyield import date_converter as dc
+from pyield.b3_futures.historical import fetch_historical_df
+from pyield.b3_futures.intraday import fetch_intraday_df
+from pyield.date_converter import DateScalar
+
+TIMEZONE_BZ = ZoneInfo("America/Sao_Paulo")
+ContractOptions = Literal["DI1", "DDI", "FRC", "DAP", "DOL", "WDO", "IND", "WIN"]
+
+
+def futures(
+    contract_code: ContractOptions,
+    trade_date: DateScalar,
+) -> pd.DataFrame:
+    """
+    Fetches data for a specified futures contract based on type and reference date.
+
+    Args:
+        contract_code (str): The B3 futures contract code identifying the derivative.
+            Supported contract codes are:
+            - "DI1": One-day Interbank Deposit Futures (Futuro de DI) from B3.
+            - "DDI": DI x U.S. Dollar Spread Futures (Futuro de Cupom Cambial) from B3.
+            - "FRC": Forward Rate Agreement (FRA) from B3.
+            - "DAP": DI x IPCA Spread Futures.
+            - "DOL": U.S. Dollar Futures from B3.
+            - "WDO": Mini U.S. Dollar Futures from B3.
+            - "IND": Ibovespa Futures from B3.
+            - "WIN": Mini Ibovespa Futures from B3.
+        trade_date (DateScalar): The date for which to fetch the data.
+            If the reference date is a string, it should be in 'DD-MM-YYYY' format.
+
+    Returns:
+        pd.DataFrame: DataFrame containing the fetched data for the specified futures
+            contract.
+
+    Raises:
+        ValueError: If the futures contract code is not recognized or supported.
+
+    Examples:
+        >>> futures("DI1", "31-05-2024")
+            TradeDate TickerSymbol  ... CloseBidRate  CloseRate
+        0  2024-05-31       DI1M24  ...      0.10404    0.10404
+        1  2024-05-31       DI1N24  ...       0.1039    0.10386
+        2  2024-05-31       DI1Q24  ...      0.10374    0.10374
+        3  2024-05-31       DI1U24  ...      0.10365    0.10355
+        ...
+        >>> futures("DAP", "31-05-2024")
+            TradeDate TickerSymbol  ... CloseBidRate  CloseRate
+        0  2024-05-31       DAPM24  ...         <NA>       <NA>
+        1  2024-05-31       DAPN24  ...         <NA>       <NA>
+        2  2024-05-31       DAPQ24  ...         <NA>     0.0885
+        3  2024-05-31       DAPU24  ...         <NA>     0.0865
+        ...
+    """
+    selected_contract = str(contract_code).upper()
+    converted_trade_date = dc.convert_input_dates(trade_date)
+
+    # First, try to fetch historical data for the specified date
+    df = fetch_historical_df(selected_contract, converted_trade_date)
+
+    bz_today = dt.datetime.now(TIMEZONE_BZ).date()
+    # If there is no historical data available, try to fetch intraday data
+    if converted_trade_date.date() == bz_today and df.empty:
+        df = fetch_intraday_df(selected_contract)
+
+    return df
+
+
+__all__ = ["futures", "ContractOptions"]

{pyield-0.26.7 → pyield-0.27.0}/pyield/tpf/lft.py

@@ -1,7 +1,8 @@
 import pandas as pd
 
-from pyield import anbima, bday
+from pyield import bday
 from pyield import date_converter as dc
+from pyield.anbima import tpf
 from pyield.date_converter import DateScalar
 from pyield.tpf import tools as tt
 
@@ -16,7 +17,7 @@ def rates(reference_date: DateScalar) -> pd.DataFrame:
     Returns:
         pd.DataFrame: DataFrame with columns "MaturityDate" and "IndicativeRate".
     """
-    lft_rates = anbima.rates(reference_date, "LFT")
+    lft_rates = tpf.anbima_tpf_rates(reference_date, "LFT")
     if lft_rates.empty:
         return pd.DataFrame()
     return lft_rates[["MaturityDate", "IndicativeRate"]]

{pyield-0.26.7 → pyield-0.27.0}/pyield/tpf/ltn.py

@@ -1,7 +1,8 @@
 import pandas as pd
 
-from pyield import anbima, bday
+from pyield import bday
 from pyield import date_converter as dc
+from pyield.anbima import tpf
 from pyield.b3_futures import di
 from pyield.date_converter import DateScalar
 from pyield.tpf import tools as tt
@@ -37,7 +38,7 @@ def rates(reference_date: DateScalar) -> pd.DataFrame:
         12   2030-01-01        0.118746
 
     """
-    ltn_rates = anbima.rates(reference_date, "LTN")
+    ltn_rates = tpf.anbima_tpf_rates(reference_date, "LTN")
     if ltn_rates.empty:
         return pd.DataFrame()
     return ltn_rates[["MaturityDate", "IndicativeRate"]]

{pyield-0.26.7 → pyield-0.27.0}/pyield/tpf/ntnb.py

@@ -4,7 +4,8 @@ import pandas as pd
 import pyield.date_converter as dc
 import pyield.interpolator as ip
 import pyield.tpf.tools as bt
-from pyield import anbima, bday
+from pyield import bday
+from pyield.anbima import tpf
 from pyield.date_converter import DateScalar
 
 """
@@ -85,7 +86,7 @@ def rates(reference_date: DateScalar) -> pd.DataFrame:
         13   2060-08-15        0.060179
 
     """
-    ntnb_rates = anbima.rates(reference_date, "NTN-B")
+    ntnb_rates = tpf.anbima_tpf_rates(reference_date, "NTN-B")
     if ntnb_rates.empty:
         return pd.DataFrame()
     return ntnb_rates[["MaturityDate", "IndicativeRate"]]

{pyield-0.26.7 → pyield-0.27.0}/pyield/tpf/ntnf.py

@@ -3,9 +3,10 @@ from collections.abc import Callable
 import numpy as np
 import pandas as pd
 
-from pyield import anbima, bday, data_cache
+from pyield import bday, data_cache
 from pyield import date_converter as dc
 from pyield import interpolator as ip
+from pyield.anbima import tpf
 from pyield.b3_futures import di
 from pyield.date_converter import DateScalar
 from pyield.tpf import tools as tt
@@ -54,7 +55,7 @@ def rates(reference_date: DateScalar) -> pd.DataFrame:
         4   2033-01-01        0.116307
         5   2035-01-01        0.116586
     """
-    ntnf_rates = anbima.rates(reference_date, "NTN-F")
+    ntnf_rates = tpf.anbima_tpf_rates(reference_date, "NTN-F")
     if ntnf_rates.empty:
         return pd.DataFrame()
     return ntnf_rates[["MaturityDate", "IndicativeRate"]]
@@ -92,7 +93,7 @@ def _check_maturity_date(maturity: pd.Timestamp) -> None:
     Check if the maturity date is a valid NTN-F maturity date.
 
     Args:
-        maturity_date (pd.Timestamp): The maturity date to be checked.
+        maturity (pd.Timestamp): The maturity date to be checked.
 
     Raises:
         ValueError: If the maturity date is not the 1st of January.

{pyield-0.26.7 → pyield-0.27.0}/pyield/tpf/tools.py

@@ -3,8 +3,8 @@ from typing import overload
 import numpy as np
 import pandas as pd
 
-from pyield import anbima
 from pyield import date_converter as dc
+from pyield.anbima import tpf
 from pyield.b3_futures.di import DIFutures
 from pyield.date_converter import DateScalar
 
@@ -88,8 +88,8 @@ def pre_spreads(reference_date: DateScalar) -> pd.DataFrame:
     df_di.rename(columns={"ExpirationDate": "MaturityDate"}, inplace=True)
 
     # Fetch bond rates, filtering for LTN and NTN-F types
-    df_ltn = anbima.rates(converted_date, "LTN")
-    df_ntnf = anbima.rates(converted_date, "NTN-F")
+    df_ltn = tpf.anbima_tpf_rates(converted_date, "LTN")
+    df_ntnf = tpf.anbima_tpf_rates(converted_date, "NTN-F")
     df_pre = pd.concat([df_ltn, df_ntnf], ignore_index=True)
 
     # Merge bond and DI rates by maturity date to calculate spreads

pyield-0.26.7/pyield/__about__.py

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