PYield 0.3.4__tar.gz → 0.3.6__tar.gz

{pyield-0.3.4 → pyield-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PYield
-Version: 0.3.4
+Version: 0.3.6
 Summary: A Python library for analysis of fixed income instruments in Brazil
 Keywords: fixed-income, brazil, finance, analysis, bonds
 Author-Email: Carlos Carvalho <cr.cj@outlook.com>
@@ -51,10 +51,11 @@ Description-Content-Type: text/markdown
 Welcome to PYield, a Python library designed for the analysis of fixed income instruments in Brazil. This library is tailored for financial analysts, researchers, and enthusiasts interested in the Brazilian fixed income market. Leveraging the power of popular Python libraries like Pandas and Requests, PYield simplifies the process of obtaining and processing data from key sources such as Tesouro Nacional (TN), Banco Central (BC), ANBIMA, and B3.
 ## Features
 
-- Data Collection: Automated fetching of data from TN, BC, ANBIMA, and B3.
-- Data Processing: Efficient processing and normalization of fixed income data.
-- Analysis Tools: Built-in functions for common analysis tasks in fixed income markets.
-- Easy Integration: Seamless integration with Python data analysis workflows.
+- **Data Collection**: Automated fetching of data from BC, ANBIMA and B3.
+- **Data Processing**: Efficient processing and normalization of fixed income data.
+- **Analysis Tools**: Built-in functions for common analysis tasks in fixed income markets.
+- **Easy Integration**: Seamless integration with Python data analysis workflows.
+- **Type Hints**: Full support for static type checking, enhancing development experience and code quality.
 
 ## Installation
 
@@ -65,18 +66,7 @@ pip install pyield
 ## How to use PYield
 ### Getting DI Futures Data
 ```python
-import pyield as pyd
-
-# Get a pandas dataframe with the DI raw data from B3 (first date available is 05-06-1991)
->>> yd.get_di(trade_date='2024-03-08', raw=True)
-VENCTO  CONTR. ABERT.(1)  CONTR. FECH.(2)  NÚM. NEGOC.  ...     AJUSTE  VAR. PTOS.  ÚLT.OF. COMPRA  ÚLT.OF. VENDA
-   J24           3608626          3608626          294  ... 99,383.080       0,17-          10.952         10.956
-   K24            607759           607759          179  ... 98,508.490       0,03+          10.774         10.780
-   M24            339641           339641          194  ... 97,706.210       1,68-          10.602         10.604
-   ...               ...              ...          ...  ...        ...         ...             ...            ...
-   F37              3517             3517            0  ... 26,863.980     336,32-           0.000          0.000
-   F38              2200             2200            0  ... 24,262.320     327,41-           0.000          0.000
-   F39                 0                0            0  ... 21,894.700     317,01-           0.000          0.000
+import pyield as yd
 
 # Get a pandas dataframe with the DI processed data from B3 (default)
 >>> yd.get_di(trade_date='2024-03-08')

{pyield-0.3.4 → pyield-0.3.6}/README.md

@@ -9,10 +9,11 @@
 Welcome to PYield, a Python library designed for the analysis of fixed income instruments in Brazil. This library is tailored for financial analysts, researchers, and enthusiasts interested in the Brazilian fixed income market. Leveraging the power of popular Python libraries like Pandas and Requests, PYield simplifies the process of obtaining and processing data from key sources such as Tesouro Nacional (TN), Banco Central (BC), ANBIMA, and B3.
 ## Features
 
-- Data Collection: Automated fetching of data from TN, BC, ANBIMA, and B3.
-- Data Processing: Efficient processing and normalization of fixed income data.
-- Analysis Tools: Built-in functions for common analysis tasks in fixed income markets.
-- Easy Integration: Seamless integration with Python data analysis workflows.
+- **Data Collection**: Automated fetching of data from BC, ANBIMA and B3.
+- **Data Processing**: Efficient processing and normalization of fixed income data.
+- **Analysis Tools**: Built-in functions for common analysis tasks in fixed income markets.
+- **Easy Integration**: Seamless integration with Python data analysis workflows.
+- **Type Hints**: Full support for static type checking, enhancing development experience and code quality.
 
 ## Installation
 
@@ -23,18 +24,7 @@ pip install pyield
 ## How to use PYield
 ### Getting DI Futures Data
 ```python
-import pyield as pyd
-
-# Get a pandas dataframe with the DI raw data from B3 (first date available is 05-06-1991)
->>> yd.get_di(trade_date='2024-03-08', raw=True)
-VENCTO  CONTR. ABERT.(1)  CONTR. FECH.(2)  NÚM. NEGOC.  ...     AJUSTE  VAR. PTOS.  ÚLT.OF. COMPRA  ÚLT.OF. VENDA
-   J24           3608626          3608626          294  ... 99,383.080       0,17-          10.952         10.956
-   K24            607759           607759          179  ... 98,508.490       0,03+          10.774         10.780
-   M24            339641           339641          194  ... 97,706.210       1,68-          10.602         10.604
-   ...               ...              ...          ...  ...        ...         ...             ...            ...
-   F37              3517             3517            0  ... 26,863.980     336,32-           0.000          0.000
-   F38              2200             2200            0  ... 24,262.320     327,41-           0.000          0.000
-   F39                 0                0            0  ... 21,894.700     317,01-           0.000          0.000
+import pyield as yd
 
 # Get a pandas dataframe with the DI processed data from B3 (default)
 >>> yd.get_di(trade_date='2024-03-08')

pyield-0.3.6/pyield/__about__.py

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

{pyield-0.3.4 → pyield-0.3.6}/pyield/__init__.py

@@ -1,4 +1,4 @@
 from .__about__ import __version__  # noqa: F401
 from .di_futures import get_di, read_di  # noqa: F401
 from .br_calendar import count_bdays, generate_bdays, offset_bdays  # noqa: F401
-from .anbima import get_anbima_rates, get_anbima_di_spreads  # noqa: F401
+from .anbima import get_treasury_rates, calculate_treasury_di_spreads  # noqa: F401

pyield-0.3.6/pyield/anbima.py

@@ -0,0 +1,195 @@
+import pandas as pd
+from urllib.error import HTTPError
+
+from . import di_futures as di
+from . import br_calendar as cl
+
+# URL Constants
+ANBIMA_NON_MEMBER_URL = "https://www.anbima.com.br/informacoes/merc-sec/arqs/"
+ANBIMA_MEMBER_URL = "http://www.anbima.associados.rtm/merc_sec/arqs/"
+
+# Constant for conversion to basis points
+BP_CONVERSION_FACTOR = 10_000
+
+
+def process_reference_date(
+    reference_date: str | pd.Timestamp | None = None,
+) -> pd.Timestamp:
+    """
+    Process the given reference date, converting it to a pandas Timestamp. If no date is provided,
+    use the previous business day based on the Brazilian calendar.
+
+    Parameters:
+    - reference_date (str | pd.Timestamp | None): The reference date to process.
+
+    Returns:
+    - pd.Timestamp: The processed reference date.
+    """
+    if reference_date:  # Force reference_date to be a pd.Timestamp
+        processed_date = pd.Timestamp(reference_date)
+    else:  # If no reference_date is given, use the previous business day
+        today = pd.Timestamp.today().normalize()
+        processed_date = cl.offset_bdays(today, -1)
+
+    return processed_date
+
+
+def get_raw_data(
+    reference_date: str | pd.Timestamp | None = None, is_anbima_member: bool = False
+) -> pd.DataFrame:
+    """
+    Fetch indicative rates from ANBIMA for a specific date.
+
+    Parameters:
+    - reference_date (pd.Timestamp): Date for which to fetch the indicative rates.
+    - is_anbima_member (bool): Whether the request is being made by an ANBIMA member.
+
+    Returns:
+    - pd.DataFrame: DataFrame with the indicative rates for the given date.
+    """
+    # Process the reference date, defaulting to the previous business day if not provided
+    validated_date = process_reference_date(reference_date)
+
+    # Format the date to match the URL format
+    url_date = validated_date.strftime("%y%m%d")
+
+    # Set the base URL according to the member status
+    base_url = ANBIMA_MEMBER_URL if is_anbima_member else ANBIMA_NON_MEMBER_URL
+    # url example: https://www.anbima.com.br/informacoes/merc-sec/arqs/ms231128.txt
+    url = f"{base_url}ms{url_date}.txt"
+
+    try:
+        df = pd.read_csv(
+            url,
+            sep="@",
+            encoding="latin-1",
+            skiprows=2,
+            decimal=",",
+            thousands=".",
+            dtype_backend="numpy_nullable",
+        )
+    except HTTPError:
+        error_date = validated_date.strftime("%d-%m-%Y")
+        raise ValueError(f"Failed to get ANBIMA rates for {error_date}")
+
+    return df
+
+
+def process_raw_data(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Process raw data from ANBIMA by filtering selected columns, renaming them, and adjusting data formats.
+
+    Parameters:
+    - df (pd.DataFrame): Raw data DataFrame to process.
+
+    Returns:
+    - pd.DataFrame: Processed DataFrame.
+    """
+    # Filter selected columns and rename them
+    selected_columns_dict = {
+        "Titulo": "BondType",
+        "Data Referencia": "ReferenceDate",
+        # "Codigo SELIC": "SelicCode",
+        # "Data Base/Emissao": "IssueBaseDate",
+        "Data Vencimento": "MaturityDate",
+        "Tx. Compra": "BidRate",
+        "Tx. Venda": "AskRate",
+        "Tx. Indicativas": "IndicativeRate",
+        "PU": "Price",
+        # "Desvio padrao": "StdDev",
+        # "Interv. Ind. Inf. (D0)",
+        # "Interv. Ind. Sup. (D0)",
+        # "Interv. Ind. Inf. (D+1)",
+        # "Interv. Ind. Sup. (D+1)",
+        # "Criterio": "Criteria",
+    }
+    select_columns = list(selected_columns_dict.keys())
+    df = df[select_columns].copy()
+    df.rename(columns=selected_columns_dict, inplace=True)
+
+    # Remove percentage from rates
+    rate_cols = ["BidRate", "AskRate", "IndicativeRate"]
+    df[rate_cols] = df[rate_cols] / 100
+
+    df["ReferenceDate"] = pd.to_datetime(df["ReferenceDate"], format="%Y%m%d")
+    df["MaturityDate"] = pd.to_datetime(df["MaturityDate"], format="%Y%m%d")
+
+    return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)
+
+
+def get_treasury_rates(
+    reference_date: str | pd.Timestamp | None = None,
+    return_raw=False,
+    is_anbima_member=False,
+) -> pd.DataFrame:
+    """
+    Fetch and process indicative rates from ANBIMA for a specific date.
+    If no date is provided, the previous business day based on the Brazilian calendar
+    is used.
+
+     Parameters:
+     - reference_date (str | pd.Timestamp | None): Date for which to fetch the indicative rates.
+        If None, previous business day based on the Brazilian calendar is used.
+     - return_raw (bool): Whether to return raw data without processing.
+     - is_anbima_member (bool): Whether the request is being made by an ANBIMA member.
+
+     Returns:
+     - pd.DataFrame: DataFrame with the indicative rates for the given date.
+    """
+
+    df = get_raw_data(reference_date, is_anbima_member)
+
+    if not return_raw:
+        df = process_raw_data(df)
+
+    return df
+
+
+def calculate_treasury_di_spreads(
+    reference_date: str | pd.Timestamp | None = None,
+    is_anbima_member=False,
+) -> pd.DataFrame:
+    """
+    Calculate the DI spread for LTN and NTN-F bonds based on ANBIMA's indicative rates.
+    If no date is provided, the previous business day based on the Brazilian calendar
+    is used.
+
+    Parameters:
+    - reference_date (str | pd.Timestamp | None): The reference date for querying ANBIMA's indicative rates.
+        If None, the previous business day based on the Brazilian calendar is used.
+    - is_anbima_member (bool): Specifies whether the request is made by an ANBIMA member.
+
+    Returns:
+    - pd.DataFrame: A DataFrame containing the bond type, reference date, maturity date, and DI spread in basis points.
+    """
+    # Process the reference date, defaulting to the previous business day if not provided
+    validated_date = process_reference_date(reference_date)
+
+    # Fetch DI rates and adjust the maturity date format for compatibility
+    df_di = di.get_di(validated_date)[["ExpirationDate", "SettlementRate"]]
+
+    # Renaming the columns to match the ANBIMA structure
+    df_di.rename(columns={"ExpirationDate": "MaturityDate"}, inplace=True)
+
+    # Adjusting maturity date to match bond data format
+    df_di["MaturityDate"] = df_di["MaturityDate"].dt.to_period("M").dt.to_timestamp()
+
+    # Fetch bond rates, filtering for LTN and NTN-F types
+    df_anbima = get_treasury_rates(
+        reference_date=validated_date, is_anbima_member=is_anbima_member
+    )
+    df_anbima.query("BondType in ['LTN', 'NTN-F']", inplace=True)
+
+    # Merge bond and DI rates by maturity date to calculate spreads
+    df_final = pd.merge(df_anbima, df_di, how="left", on="MaturityDate")
+
+    # Calculating the DI spread as the difference between indicative and settlement rates
+    df_final["DISpread"] = df_final["IndicativeRate"] - df_final["SettlementRate"]
+
+    # Convert spread to basis points for clarity
+    df_final["DISpread"] = (BP_CONVERSION_FACTOR * df_final["DISpread"]).round(2)
+
+    # Prepare and return the final sorted DataFrame
+    select_columns = ["BondType", "ReferenceDate", "MaturityDate", "DISpread"]
+    df_final = df_final[select_columns].copy()
+    return df_final.sort_values(["BondType", "MaturityDate"], ignore_index=True)

{pyield-0.3.4 → pyield-0.3.6}/pyield/br_calendar.py

@@ -3,14 +3,14 @@ from typing import Literal
 import pandas as pd
 import numpy as np
 
-from .br_holidays import BRHolidays
+from .br_holidays import BrHolidays
 
 # Instância global da classe Holidays
-br_holidays = BRHolidays()
+br_holidays = BrHolidays()
 
 
 def convert_to_numpy_date(
-    dates: str | pd.Timestamp | pd.Series,
+    dates: pd.Timestamp | pd.Series,
 ) -> np.datetime64 | np.ndarray:
     """
     Converts the input dates to a numpy datetime64[D] format.
@@ -21,13 +21,10 @@ def convert_to_numpy_date(
     Returns:
         np.datetime64 | np.ndarray: The input dates in a numpy datetime64[D] format.
     """
-    # Assure that the input is in pandas datetime64[ns] format
-    dates_pd = pd.to_datetime(dates)
-
-    if isinstance(dates_pd, pd.Timestamp):
-        return np.datetime64(dates_pd, "D")
+    if isinstance(dates, pd.Timestamp):
+        return np.datetime64(dates, "D")
     else:
-        return dates_pd.to_numpy().astype("datetime64[D]")
+        return dates.to_numpy().astype("datetime64[D]")
 
 
 def offset_bdays(
@@ -68,17 +65,19 @@ def offset_bdays(
         >>> yd.offset_bdays(date, -1)
         Timestamp('2023-12-21') # Offset to the previous business day
     """
-    dates_np = convert_to_numpy_date(dates)
+    # Assure that the input is in pandas datetime64[ns] format
+    dates_pd = pd.to_datetime(dates)
 
-    selected_holidays = br_holidays.get_applicable_holidays(dates_np, holiday_list)
+    selected_holidays = br_holidays.get_applicable_holidays(dates_pd, holiday_list)
+    selected_holidays_np = convert_to_numpy_date(selected_holidays)
 
-    # Offset the dates
-    offsetted_dates = np.busday_offset(
-        dates_np, offsets=offset, roll="forward", holidays=selected_holidays
+    dates_np = convert_to_numpy_date(dates_pd)
+    offsetted_dates_np = np.busday_offset(
+        dates_np, offsets=offset, roll="forward", holidays=selected_holidays_np
     )
 
     # Convert the dates back to a pandas datetime64[ns] format
-    return pd.to_datetime(offsetted_dates, unit="ns")
+    return pd.to_datetime(offsetted_dates_np, unit="ns")
 
 
 def count_bdays(start, end, holiday_list: Literal["old", "new", "infer"] = "infer"):
@@ -118,19 +117,24 @@ def count_bdays(start, end, holiday_list: Literal["old", "new", "infer"] = "infe
         >>> yd.count_bdays(start, end)
         array([22, 40])
     """
-    # Convert inputs to a Series of datetime64[ns] even if a single value was passed
-    start_np = convert_to_numpy_date(start)
-    end_np = convert_to_numpy_date(end)
+    # Assure that the inputs are in pandas datetime64[ns] format
+    start_pd = pd.to_datetime(start)
+    end_pd = pd.to_datetime(end)
 
     # Determine which list of holidays to use
-    selected_holidays = br_holidays.get_applicable_holidays(start_np, holiday_list)
+    selected_holidays = br_holidays.get_applicable_holidays(start_pd, holiday_list)
+    selected_holidays_np = convert_to_numpy_date(selected_holidays)
+
+    # Convert inputs to numpy datetime64[D] before calling numpy.busday_count
+    start_np = convert_to_numpy_date(start_pd)
+    end_np = convert_to_numpy_date(end_pd)
 
-    return np.busday_count(start_np, end_np, holidays=selected_holidays)
+    return np.busday_count(start_np, end_np, holidays=selected_holidays_np)
 
 
 def generate_bdays(
-    start=None,
-    end=None,
+    start: str | pd.Timestamp | None = None,
+    end: str | pd.Timestamp | None = None,
     inclusive="both",
     holiday_list: Literal["old", "new", "infer"] = "infer",
     **kwargs,
@@ -175,15 +179,24 @@ def generate_bdays(
         2023-12-29    2023-12-29
         dtype: object
     """
-    if start is None:
-        start = pd.Timestamp.today()
+    if start:
+        start_pd = pd.to_datetime(start)
+    else:
+        start_pd = pd.Timestamp.today().normalize()
 
-    if end is None:
-        end = pd.Timestamp.today()
+    if end:
+        end_pd = pd.to_datetime(end)
+    else:
+        end_pd = pd.Timestamp.today().normalize()
 
-    start_np = convert_to_numpy_date(start)
-    selected_holidays = br_holidays.get_applicable_holidays(start_np, holiday_list)
+    selected_holidays = br_holidays.get_applicable_holidays(start_pd, holiday_list)
+    selected_holidays_list = selected_holidays.to_list()
 
     return pd.bdate_range(
-        start, end, freq="C", inclusive=inclusive, holidays=selected_holidays, **kwargs
+        start_pd,
+        end_pd,
+        freq="C",
+        inclusive=inclusive,
+        holidays=selected_holidays_list,
+        **kwargs,
     )

{pyield-0.3.4 → pyield-0.3.6}/pyield/br_holidays.py

@@ -2,12 +2,11 @@ from pathlib import Path
 from typing import Literal
 
 import pandas as pd
-import numpy as np
 
 
-class BRHolidays:
+class BrHolidays:
     # The date (inclusive) when the new holidays list starts to be valid
-    TRANSITION_DATE = np.datetime64("2023-12-26", "D")
+    TRANSITION_DATE = pd.to_datetime("2023-12-26")
 
     def __init__(self):
         current_dir = Path(__file__).parent
@@ -16,34 +15,33 @@ class BRHolidays:
         self.new_holidays = self._load_holidays(new_holidays_path)
         self.old_holidays = self._load_holidays(old_holidays_path)
 
-    def _load_holidays(self, file_path: Path) -> np.array:
+    def _load_holidays(self, file_path: Path) -> pd.Series:
+        """Loads the list of holidays from a text file and returns it as a pd.Series of pd.Timestamp."""
         df = pd.read_csv(file_path, header=None, names=["date"], comment="#")
-        holiday_dates = pd.to_datetime(df["date"], format="%d/%m/%Y")
-        # Return the dates as a numpy array of datetime64[D]
-        return holiday_dates.values.astype("datetime64[D]")
+        # Convert the dates to a pd.Series of pd.Timestamp
+        return pd.to_datetime(df["date"], format="%d/%m/%Y")
 
     def get_applicable_holidays(
         self,
-        dates: np.datetime64 | np.ndarray,
+        dates: pd.Timestamp | pd.Series,
         holiday_list: Literal["old", "new", "infer"] = "infer",
-    ) -> np.array:
+    ) -> pd.Series:
         """
         Returns the correct list of holidays to use based on the most recent date in the input.
 
         Args:
-            dates (np.datetime64 | np.ndarray): The date(s) to use to determine the list of
-                holidays.
+            dates (pd.Timestamp | pd.Series): The date(s) to use to infer the holidays.
             holiday_list (str): The holidays list to use. Valid options are 'old', 'new' or
                 'infer'. If 'infer' is used, the list of holidays is selected based on the
                 earliest (minimum) date in the input.
 
         Returns:
-            np.array: The list of holidays to use.
+            pd.Series: The list of holidays to use.
         """
-        if isinstance(dates, np.datetime64):
+        if isinstance(dates, pd.Timestamp):
             earliest_date = dates
         else:
-            earliest_date = np.min(dates)
+            earliest_date = dates.min()
 
         match holiday_list:
             case "old":
@@ -51,7 +49,7 @@ class BRHolidays:
             case "new":
                 return self.new_holidays
             case "infer":
-                if earliest_date < BRHolidays.TRANSITION_DATE:
+                if earliest_date < BrHolidays.TRANSITION_DATE:
                     return self.old_holidays
                 else:
                     return self.new_holidays

{pyield-0.3.4 → pyield-0.3.6}/pyield/di_futures.py

@@ -1,13 +1,14 @@
-from typing import Literal
+from typing import Literal, Optional
 from pathlib import Path
 import pandas as pd
+import pandas.api.types
 
 from . import di_web as diw
 from . import di_xml as dix
 from . import br_calendar as brc
 
 
-def get_expiration_date(expiration_code: str) -> pd.Timestamp:
+def get_expiration_date(expiration_code: str) -> Optional[pd.Timestamp]:
     """
     Internal function to convert the expiration code into its expiration date.
 
@@ -66,7 +67,7 @@ def get_expiration_date(expiration_code: str) -> pd.Timestamp:
         return brc.offset_bdays(expiration, offset=0)
 
     except (KeyError, ValueError):
-        return pd.NaT
+        return pd.NaT  # type: ignore
 
 
 def get_di(

{pyield-0.3.4 → pyield-0.3.6}/pyield/di_web.py

@@ -1,5 +1,6 @@
 import io
 import warnings
+from typing import Optional
 
 import pandas as pd
 import requests
@@ -10,7 +11,7 @@ from . import di_futures as dif
 
 def get_old_expiration_date(
     ExpirationCode: str, trade_date: pd.Timestamp
-) -> pd.Timestamp:
+) -> Optional[pd.Timestamp]:
     """
     Internal function to convert an old DI contract code into its ExpirationDate date. Valid for
     contract codes up to 21-05-2006.
@@ -67,7 +68,7 @@ def get_old_expiration_date(
         return brc.offset_bdays(ExpirationDate, offset=0, holiday_list="old")
 
     except (KeyError, ValueError):
-        return pd.NaT
+        return pd.NaT  # type: ignore
 
 
 def get_raw_di(trade_date: pd.Timestamp) -> pd.DataFrame:

{pyield-0.3.4 → pyield-0.3.6}/pyield/di_xml.py

@@ -57,7 +57,7 @@ def extract_xml_from_zip(zip_file: io.BytesIO) -> io.BytesIO:
     return io.BytesIO(inner_file_content)
 
 
-def extract_di_data_from_xml(xml_file: io.BytesIO) -> list:
+def extract_di_data_from_xml(xml_file: io.BytesIO) -> list[dict]:
     parser = etree.XMLParser(
         ns_clean=True, remove_blank_text=True, remove_comments=True, recover=True
     )
@@ -69,18 +69,38 @@ def extract_di_data_from_xml(xml_file: io.BytesIO) -> list:
         '//ns:TckrSymb[starts-with(text(), "DI1")]', namespaces=namespaces
     )
 
-    # Lista para armazenar os dados
+    if (
+        tckr_symbols is None
+        or not isinstance(tckr_symbols, list)
+        or len(tckr_symbols) == 0
+    ):
+        return []
+
+    # Lista para armazenar os dados com type hinting
+    # di_data: list[dict] = []
     di_data = []
 
     # Processar cada TckrSymb encontrado
     for tckr_symb in tckr_symbols:
-        # Acessar o elemento PricRpt que contém o TckrSymb
-        price_report = tckr_symb.getparent().getparent()
+        if isinstance(tckr_symb, etree._Element):
+            price_report = tckr_symb.getparent()
+            if price_report is not None:
+                price_report = price_report.getparent()
+            else:
+                # Handle the case where tckr_symb doesn't have a parent
+                continue
+        else:
+            # Handle the case where tckr_symb is not an _Element
+            continue
 
         # Extrair a data de negociação
+        if price_report is None:
+            continue
         trade_date = price_report.find(".//ns:TradDt/ns:Dt", namespaces)
 
         # Preparar o dicionário de dados do ticker com a data de negociação
+        if trade_date is None:
+            continue
         ticker_data = {"TradDt": trade_date.text, "TckrSymb": tckr_symb.text}
 
         # Acessar o elemento FinInstrmAttrbts que contém o TckrSymb

{pyield-0.3.4 → pyield-0.3.6}/pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
     "lxml",
 ]
 dynamic = []
-version = "0.3.4"
+version = "0.3.6"
 
 [project.license]
 file = "LICENSE"
@@ -50,4 +50,5 @@ path = "pyield/__about__.py"
 dev = [
     "ipykernel",
     "pytest",
+    "mypy",
 ]

pyield-0.3.4/pyield/__about__.py

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

pyield-0.3.4/pyield/anbima.py

@@ -1,155 +0,0 @@
-import pandas as pd
-from urllib.error import HTTPError
-
-from . import di_futures as di
-
-
-def process_reference_date(
-    reference_date: str | pd.Timestamp | None = None,
-) -> pd.Timestamp:
-    if reference_date:
-        # Force reference_date to be a pd.Timestamp
-        reference_date = pd.Timestamp(reference_date)
-    else:  # If no reference_date is given, use yesterday's date
-        today = pd.Timestamp.today().date()
-        yesterday = today - pd.Timedelta(days=1)
-        reference_date = yesterday
-
-    return reference_date
-
-
-def get_raw_data(reference_date: pd.Timestamp, anbima_member: bool) -> pd.DataFrame:
-    """
-    Fetch indicative rates from ANBIMA for a specific date.
-
-    Parameters:
-    - reference_date: pd.Timestamp for which to fetch the indicative rates.
-        If None, fetches yesterday's rates.
-
-    Returns:
-    - A pandas DataFrame with the indicative rates for the given date.
-    """
-
-    # Example URL: https://www.anbima.com.br/informacoes/merc-sec/arqs/ms231128.txt
-    url_date = reference_date.strftime("%y%m%d")
-    if anbima_member:
-        url = f"http://www.anbima.associados.rtm/merc_sec/arqs/ms{url_date}.txt"
-    else:
-        url = f"https://www.anbima.com.br/informacoes/merc-sec/arqs/ms{url_date}.txt"
-
-    try:
-        df = pd.read_csv(
-            url,
-            sep="@",
-            encoding="latin-1",
-            skiprows=2,
-            decimal=",",
-            thousands=".",
-            dtype_backend="numpy_nullable",
-        )
-    except HTTPError:
-        error_date = reference_date.strftime("%d-%m-%Y")
-        raise ValueError(f"Failed to get ANBIMA rates for {error_date}")
-
-    return df
-
-
-def process_raw_data(df: pd.DataFrame) -> pd.DataFrame:
-    # Filter selected columns and rename them
-    selected_columns_dict = {
-        "Titulo": "BondType",
-        "Data Referencia": "ReferenceDate",
-        # "Codigo SELIC": "SelicCode",
-        # "Data Base/Emissao": "IssueBaseDate",
-        "Data Vencimento": "MaturityDate",
-        "Tx. Compra": "BidRate",
-        "Tx. Venda": "AskRate",
-        "Tx. Indicativas": "IndicativeRate",
-        "PU": "Price",
-        # "Desvio padrao": "StdDev",
-        # "Interv. Ind. Inf. (D0)",
-        # "Interv. Ind. Sup. (D0)",
-        # "Interv. Ind. Inf. (D+1)",
-        # "Interv. Ind. Sup. (D+1)",
-        # "Criterio": "Criteria",
-    }
-    select_columns = list(selected_columns_dict.keys())
-    df = df[select_columns].copy()
-    df.rename(columns=selected_columns_dict, inplace=True)
-
-    # Remove percentage from rates
-    rate_cols = ["BidRate", "AskRate", "IndicativeRate"]
-    df[rate_cols] = df[rate_cols] / 100
-
-    df["ReferenceDate"] = pd.to_datetime(df["ReferenceDate"], format="%Y%m%d")
-    df["MaturityDate"] = pd.to_datetime(df["MaturityDate"], format="%Y%m%d")
-
-    return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)
-
-
-def get_anbima_rates(
-    reference_date: str | pd.Timestamp | None = None,
-    return_raw=False,
-    anbima_member=False,
-) -> pd.DataFrame:
-    """
-    Fetch indicative rates from ANBIMA for a specific date.
-
-    Parameters:
-    - reference_date: pd.Timestamp for which to fetch the indicative rates.
-        If None, fetches yesterday's rates.
-
-    Returns:
-    - A pandas DataFrame with the indicative rates for the given date.
-    """
-    reference_date = process_reference_date(reference_date)
-    df = get_raw_data(reference_date, anbima_member)
-
-    if return_raw:
-        return df
-    else:
-        return process_raw_data(df)
-
-
-def get_anbima_di_spreads(
-    reference_date: str | pd.Timestamp | None = None,
-    anbima_member=False,
-) -> pd.DataFrame:
-    """
-    Calcula o prêmio (spread) com relação ao DI nas taxas indicativas da ANBIMA para os títulos LTN e NTN-F.
-    A coluna DISpread contém o prêmio em bps.
-
-    Parâmetros:
-    -----------
-    data_consulta : pd.Timestamp
-        A data de referência para a consulta das taxas indicativas da ANBIMA.
-    """
-    reference_date = process_reference_date(reference_date)
-
-    df_di = di.get_di(reference_date)[["ExpirationDate", "SettlementRate"]]
-
-    df_di.rename(columns={"ExpirationDate": "MaturityDate"}, inplace=True)
-
-    # Ajustar o vencimento para o primeiro dia do mês para concidir com o formato dos títulos
-    df_di["MaturityDate"] = df_di["MaturityDate"].dt.to_period("M").dt.to_timestamp()
-
-    df_anb = get_anbima_rates(
-        reference_date=reference_date, anbima_member=anbima_member
-    )
-
-    # Filtrar apenas os títulos LTN e NTN-F
-    df_anb.query("BondType in ['LTN', 'NTN-F']", inplace=True)
-
-    # Unir os dois DataFrames
-    df = pd.merge(df_anb, df_di, how="left", on="MaturityDate")
-
-    # Calcular o prêmio implícito na taxa da ANBIMA
-    df["DISpread"] = df["IndicativeRate"] - df["SettlementRate"]
-    df.drop(columns="SettlementRate", inplace=True)
-
-    # Converter o prêmio para bps e arredondar para 2 casas decimais
-    df["DISpread"] = (10_000 * df["DISpread"]).round(2)
-
-    select_columns = ["BondType", "ReferenceDate", "MaturityDate", "DISpread"]
-    df = df[select_columns]
-    return df.sort_values(["BondType", "MaturityDate"], ignore_index=True)