PYield 0.4.0__tar.gz → 0.5.0__tar.gz

{pyield-0.4.0 → pyield-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PYield
-Version: 0.4.0
+Version: 0.5.0
 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>

pyield-0.5.0/pyield/__about__.py

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

{pyield-0.4.0 → pyield-0.5.0}/pyield/__init__.py

@@ -1,6 +1,6 @@
 from .__about__ import __version__
-from .di_futures import get_di, read_di
-from .br_calendar import count_bdays, generate_bdays, offset_bdays, is_business_day
+from .di import get_di, read_di
+from .calendar import count_bdays, generate_bdays, offset_bdays, is_business_day
 from .anbima import get_treasury_rates, calculate_treasury_di_spreads
 
 __all__ = [

{pyield-0.4.0 → pyield-0.5.0}/pyield/anbima.py

@@ -1,25 +1,29 @@
+import io
+
 import pandas as pd
+import requests
+
 from pandas import Timestamp, DataFrame
-from urllib.error import HTTPError
 
-from . import di_futures as di
-from . import br_calendar as cl
+from . import di
+from . import 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
+BPS_CONVERSION_FACTOR = 10_000
 
 
-def normalize_date(reference_date: str | Timestamp | None = None) -> Timestamp:
+def _normalize_date(reference_date: str | Timestamp | None = None) -> Timestamp:
     if isinstance(reference_date, str):
         normalized_date = pd.Timestamp(reference_date).normalize()
     elif isinstance(reference_date, Timestamp):
         normalized_date = reference_date.normalize()
     elif reference_date is None:
         today = pd.Timestamp.today().normalize()
+        # Get last business day before today
         normalized_date = cl.offset_bdays(today, -1)
     else:
         raise ValueError("Invalid date format.")
@@ -35,48 +39,51 @@ def normalize_date(reference_date: str | Timestamp | None = None) -> Timestamp:
     return normalized_date
 
 
-def get_raw_data(
-    reference_date: str | Timestamp | None = None, is_anbima_member: bool = False
-) -> 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
-    normalized_date = normalize_date(reference_date)
-
-    # Format the date to match the URL format
-    url_date = normalized_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"
+def _get_anbima_content(reference_date: Timestamp) -> str:
+    url_date = reference_date.strftime("%y%m%d")
+    member_url = f"{ANBIMA_MEMBER_URL}ms{url_date}.txt"
+    non_member_url = f"{ANBIMA_NON_MEMBER_URL}ms{url_date}.txt"
 
+    # Tries to access the member URL first
     try:
-        df = pd.read_csv(
-            url,
-            sep="@",
-            encoding="latin-1",
-            skiprows=2,
-            decimal=",",
-            thousands=".",
-            dtype_backend="numpy_nullable",
-        )
-    except HTTPError:
-        error_date = normalized_date.strftime("%d-%m-%Y")
-        raise ValueError(f"Failed to get ANBIMA rates for {error_date}")
-
+        response = requests.get(member_url)
+        # Checks if the response was successful (status code 200)
+        response.raise_for_status()
+        return response.text
+    except requests.exceptions.RequestException:
+        # Blind attempt to access the member URL
+        pass
+
+    # If the member URL fails, tries to access the non-member URL
+    try:
+        response = requests.get(non_member_url)
+        response.raise_for_status()  # Checks if the second attempt was successful
+        return response.text
+    except requests.exceptions.RequestException:
+        # Both URLs failed
+        return ""
+
+
+def _get_raw_data(reference_date: Timestamp) -> DataFrame:
+    url_content = _get_anbima_content(reference_date)
+    if url_content == "":
+        date_str = reference_date.strftime("%d-%m-%Y")
+        raise ValueError(f"Could not fetch ANBIMA data for {date_str}.")
+
+    df = pd.read_csv(
+        io.StringIO(url_content),
+        sep="@",
+        encoding="latin-1",
+        skiprows=2,
+        decimal=",",
+        thousands=".",
+        na_values=["--"],
+        dtype_backend="numpy_nullable",
+    )
     return df
 
 
-def process_raw_data(df_raw: DataFrame) -> DataFrame:
+def _process_raw_data(df_raw: DataFrame) -> DataFrame:
     """
     Process raw data from ANBIMA by filtering selected columns, renaming them, and adjusting data formats.
 
@@ -121,7 +128,6 @@ def process_raw_data(df_raw: DataFrame) -> DataFrame:
 def get_treasury_rates(
     reference_date: str | Timestamp | None = None,
     return_raw=False,
-    is_anbima_member=False,
 ) -> DataFrame:
     """
     Fetch and process indicative rates from ANBIMA for a specific date.
@@ -130,26 +136,24 @@ def get_treasury_rates(
 
      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.
+        If None, the 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.
     """
 
-    normalized_date = normalize_date(reference_date)
-    df = get_raw_data(normalized_date, is_anbima_member)
+    normalized_date = _normalize_date(reference_date)
+    df = _get_raw_data(normalized_date)
 
     if not return_raw:
-        df = process_raw_data(df)
+        df = _process_raw_data(df)
 
     return df
 
 
 def calculate_treasury_di_spreads(
     reference_date: str | Timestamp | None = None,
-    is_anbima_member=False,
 ) -> DataFrame:
     """
     Calculate the DI spread for LTN and NTN-F bonds based on ANBIMA's indicative rates.
@@ -159,13 +163,12 @@ def calculate_treasury_di_spreads(
     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.
     """
     # Validate the reference date, defaulting to the previous business day if not provided
-    normalized_date = normalize_date(reference_date)
+    normalized_date = _normalize_date(reference_date)
 
     # Fetch DI rates and adjust the maturity date format for compatibility
     df_di = di.get_di(normalized_date)[["ExpirationDate", "SettlementRate"]]
@@ -177,7 +180,7 @@ def calculate_treasury_di_spreads(
     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(normalized_date, False, is_anbima_member)
+    df_anbima = get_treasury_rates(normalized_date, False)
     df_anbima.query("BondType in ['LTN', 'NTN-F']", inplace=True)
 
     # Merge bond and DI rates by maturity date to calculate spreads
@@ -187,7 +190,7 @@ def calculate_treasury_di_spreads(
     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)
+    df_final["DISpread"] = (BPS_CONVERSION_FACTOR * df_final["DISpread"]).round(2)
 
     # Prepare and return the final sorted DataFrame
     select_columns = ["BondType", "ReferenceDate", "MaturityDate", "DISpread"]

pyield-0.4.0/pyield/br_calendar.py → pyield-0.5.0/pyield/calendar.py

@@ -1,37 +1,52 @@
-from typing import Literal, overload
+from typing import Literal, overload, Union
+from datetime import datetime
 
 import numpy as np
 import pandas as pd
-from pandas import Series, Timestamp
 
-from .br_holidays import BrHolidays
 
-# Instância global da classe Holidays
+from .holidays import BrHolidays
+
+SingleDateType = Union[str, np.datetime64, pd.Timestamp, datetime]
+
+SeriesDateType = Union[list, tuple, np.ndarray, pd.Series, pd.Index, pd.DatetimeIndex]
+
+TO_TIMESTAMP_TYPES = (str, np.datetime64, datetime)
+TO_SERIES_TYPES = (list, tuple, np.ndarray, pd.Series, pd.Index, pd.DatetimeIndex)
+
+# Initialize the BrHolidays class
 br_holidays = BrHolidays()
 
 
 @overload
-def normalize_input_dates(dates: str | Timestamp | None) -> Timestamp: ...
+def _normalize_input_dates(
+    dates: SingleDateType | None,
+) -> pd.Timestamp: ...
 
 
 @overload
-def normalize_input_dates(dates: Series) -> Series: ...
+def _normalize_input_dates(
+    dates: SeriesDateType,
+) -> pd.Series: ...
 
 
-def normalize_input_dates(dates: str | Timestamp | Series | None) -> Timestamp | Series:
-    if isinstance(dates, str):
-        return pd.Timestamp(dates).normalize()
-    elif isinstance(dates, Timestamp):
-        return dates.normalize()
-    elif isinstance(dates, Series):
-        return pd.to_datetime(dates)
-    elif dates is None:
+def _normalize_input_dates(
+    dates: SingleDateType | SeriesDateType | None = None,
+) -> pd.Timestamp | pd.Series:
+    if dates is None:
         return pd.Timestamp.today().normalize()
+    elif isinstance(dates, pd.Timestamp):
+        return dates.normalize()
+    elif isinstance(dates, TO_TIMESTAMP_TYPES):
+        return pd.Timestamp(dates).normalize()
+    elif isinstance(dates, TO_SERIES_TYPES):
+        result = pd.to_datetime(dates)
+        return pd.Series(result).dt.normalize()
     else:
         raise ValueError("Invalid date format.")
 
 
-def is_business_day(date: str | Timestamp | None = None) -> bool:
+def is_business_day(date: SingleDateType | None = None) -> bool:
     """
     Checks if the input date is a business day.
 
@@ -47,13 +62,15 @@ def is_business_day(date: str | Timestamp | None = None) -> bool:
         >>> yd.is_business_day() # Check if today is a business day
         True
     """
-    normalized_date = normalize_input_dates(date)
+    normalized_date = _normalize_input_dates(date)
     # Shift the date if it is not a business day
     adjusted_date = offset_bdays(normalized_date, 0)
     return normalized_date == adjusted_date
 
 
-def convert_to_numpy_date(dates: Timestamp | Series) -> np.datetime64 | np.ndarray:
+def _convert_to_numpy_date(
+    dates: pd.Timestamp | pd.Series,
+) -> np.datetime64 | np.ndarray:
     """
     Converts the input dates to a numpy datetime64[D] format.
 
@@ -71,28 +88,28 @@ def convert_to_numpy_date(dates: Timestamp | Series) -> np.datetime64 | np.ndarr
 
 @overload
 def offset_bdays(
-    dates: str | Timestamp | None = None,
+    dates: SingleDateType | None = None,
     offset: int = 0,
     roll: Literal["forward", "backward"] = "forward",
     holiday_list: Literal["old", "new", "infer"] = "infer",
-) -> Timestamp: ...
+) -> pd.Timestamp: ...
 
 
 @overload
 def offset_bdays(
-    dates: Series,
+    dates: SeriesDateType,
     offset: int = 0,
     roll: Literal["forward", "backward"] = "forward",
     holiday_list: Literal["old", "new", "infer"] = "infer",
-) -> Series: ...
+) -> pd.Series: ...
 
 
 def offset_bdays(
-    dates: str | Timestamp | Series | None = None,
+    dates: SingleDateType | SeriesDateType | None = None,
     offset: int = 0,
     roll: Literal["forward", "backward"] = "forward",
     holiday_list: Literal["old", "new", "infer"] = "infer",
-) -> Timestamp | Series:
+) -> pd.Timestamp | pd.Series:
     """
     Offsets the dates to the next or previous business day. This function is a wrapper
     for `numpy.busday_offset` to be used directly with Pandas data types that infers the
@@ -129,14 +146,14 @@ def offset_bdays(
         >>> yd.offset_bdays(date, -1)
         Timestamp('2023-12-21') # Offset to the previous business day
     """
-    normalized_dates = normalize_input_dates(dates)
+    normalized_dates = _normalize_input_dates(dates)
 
     selected_holidays = br_holidays.get_applicable_holidays(
         normalized_dates, holiday_list
     )
-    selected_holidays_np = convert_to_numpy_date(selected_holidays)
+    selected_holidays_np = _convert_to_numpy_date(selected_holidays)
 
-    dates_np = convert_to_numpy_date(normalized_dates)
+    dates_np = _convert_to_numpy_date(normalized_dates)
     offsetted_dates_np = np.busday_offset(
         dates_np, offsets=offset, roll=roll, holidays=selected_holidays_np
     )
@@ -149,33 +166,41 @@ def offset_bdays(
 
 @overload
 def count_bdays(
-    start: str | Timestamp | None = None,
-    end: str | Timestamp | None = None,
+    start: SingleDateType | None = None,
+    end: SingleDateType | None = None,
     holiday_list: Literal["old", "new", "infer"] = "infer",
 ) -> int: ...
 
 
 @overload
 def count_bdays(
-    start: Series,
-    end: str | Timestamp | Series | None,
+    start: SeriesDateType,
+    end: SingleDateType | None,
+    holiday_list: Literal["old", "new", "infer"] = "infer",
+) -> pd.Series: ...
+
+
+@overload
+def count_bdays(
+    start: SingleDateType | None,
+    end: SeriesDateType,
     holiday_list: Literal["old", "new", "infer"] = "infer",
-) -> Series: ...
+) -> pd.Series: ...
 
 
 @overload
 def count_bdays(
-    start: str | Timestamp | Series | None,
-    end: Series,
+    start: SeriesDateType,
+    end: SeriesDateType,
     holiday_list: Literal["old", "new", "infer"] = "infer",
-) -> Series: ...
+) -> pd.Series: ...
 
 
 def count_bdays(
-    start: str | Timestamp | Series | None = None,
-    end: str | Timestamp | Series | None = None,
+    start: SingleDateType | SeriesDateType | None = None,
+    end: SingleDateType | SeriesDateType | None = None,
     holiday_list: Literal["old", "new", "infer"] = "infer",
-) -> int | Series:
+) -> int | pd.Series:
     """
     Counts the number of business days between a `start` (inclusive) and `end`
     (exclusive). If an end date is earlier than the start date, the count will be
@@ -192,7 +217,7 @@ def count_bdays(
             the input.
 
     Returns:
-        int | Series: The number of business days between the start date and end date.
+        int | Series | list: The number of business days between the start date and end date.
         Returns an integer if the result is a single value, otherwise returns a Series.
 
     Notes:
@@ -213,34 +238,33 @@ def count_bdays(
         >>> yd.count_bdays(start, end)
         pd.Series([22, 40], dtype='int64')
     """
-    normalized_start = normalize_input_dates(start)
-    normalized_end = normalize_input_dates(end)
+    normalized_start = _normalize_input_dates(start)
+    normalized_end = _normalize_input_dates(end)
 
     # Determine which list of holidays to use
     selected_holidays = br_holidays.get_applicable_holidays(
         normalized_start, holiday_list
     )
-    selected_holidays_np = convert_to_numpy_date(selected_holidays)
+    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(normalized_start)
-    end_np = convert_to_numpy_date(normalized_end)
+    start_np = _convert_to_numpy_date(normalized_start)
+    end_np = _convert_to_numpy_date(normalized_end)
 
     result_np = np.busday_count(start_np, end_np, holidays=selected_holidays_np)
-    if isinstance(result_np, np.ndarray):
-        # Return pandas Int64 type for type consistency
-        return pd.Series(result_np, dtype="Int64")
-    else:
+    if isinstance(result_np, np.int64):
         return int(result_np)
+    else:
+        return pd.Series(result_np, dtype="Int64")
 
 
 def generate_bdays(
-    start: str | Timestamp | None = None,
-    end: str | Timestamp | None = None,
+    start: SingleDateType | None = None,
+    end: SingleDateType | None = None,
     inclusive: Literal["both", "neither", "left", "right"] = "both",
     holiday_list: Literal["old", "new", "infer"] = "infer",
     **kwargs,
-) -> Series:
+) -> pd.Series:
     """
     Generates a Series of business days between a `start` (inclusive) and `end`
     (inclusive) that takes into account the list of brazilian holidays as the default.
@@ -283,11 +307,8 @@ def generate_bdays(
         2023-12-29    2023-12-29
         dtype: object
     """
-    normalized_start = normalize_input_dates(start)
-    normalized_end = normalize_input_dates(end)
-
-    if isinstance(normalized_start, Series) or isinstance(normalized_end, Series):
-        raise ValueError("The start and end dates must be single dates.")
+    normalized_start = _normalize_input_dates(start)
+    normalized_end = _normalize_input_dates(end)
 
     selected_holidays = br_holidays.get_applicable_holidays(
         normalized_start, holiday_list

pyield-0.5.0/pyield/di/__init__.py

@@ -0,0 +1,6 @@
+from .core import get_di, read_di
+
+__all__ = [
+    "get_di",
+    "read_di",
+]

pyield-0.4.0/pyield/di_futures.py → pyield-0.5.0/pyield/di/core.py

@@ -4,19 +4,20 @@ from pathlib import Path
 import pandas as pd
 from pandas import DataFrame, Timestamp
 
-from . import di_web as diw
-from . import di_xml as dix
-from . import br_calendar as brc
+from . import web as wb
+from . import xml as dix
+from .. import calendar as cl
 
 
-def normalize_date(trade_date: str | Timestamp | None = None) -> Timestamp:
+def _normalize_date(trade_date: str | Timestamp | None = None) -> Timestamp:
     if isinstance(trade_date, str):
         normalized_date = pd.Timestamp(trade_date).normalize()
     elif isinstance(trade_date, Timestamp):
         normalized_date = trade_date.normalize()
     elif trade_date is None:
         today = pd.Timestamp.today().normalize()
-        normalized_date = brc.offset_bdays(today, -1)
+        # Get last business day before today
+        normalized_date = cl.offset_bdays(today, -1)
     else:
         raise ValueError("Invalid date format.")
 
@@ -25,7 +26,7 @@ def normalize_date(trade_date: str | Timestamp | None = None) -> Timestamp:
         raise ValueError("Trade date cannot be in the future.")
 
     # Raise error if the reference date is not a business day
-    if not brc.is_business_day(normalized_date):
+    if not cl.is_business_day(normalized_date):
         raise ValueError("Trade date must be a business day.")
 
     return normalized_date
@@ -88,7 +89,7 @@ def get_expiration_date(expiration_code: str) -> Timestamp:
         expiration = pd.Timestamp(year, month, 1)
 
         # Adjust to the next business day when expiration date is a weekend or a holiday
-        adj_expiration = brc.offset_bdays(expiration, offset=0)
+        adj_expiration = cl.offset_bdays(expiration, offset=0)
 
         return adj_expiration
 
@@ -136,10 +137,10 @@ def get_di(
 
     """
     # Force trade_date to be a pandas Timestamp
-    normalized_trade_date = normalize_date(trade_date)
+    normalized_trade_date = _normalize_date(trade_date)
 
     if source_type == "bmf":
-        return diw.get_di(normalized_trade_date, return_raw)
+        return wb.get_di(normalized_trade_date, return_raw)
     elif source_type in ["b3", "b3s"]:
         return dix.get_di(normalized_trade_date, source_type, return_raw)
     else:

pyield-0.4.0/pyield/di_web.py → pyield-0.5.0/pyield/di/web.py

@@ -6,8 +6,8 @@ import pandas as pd
 from pandas import Timestamp, Series, DataFrame
 import requests
 
-from . import br_calendar as brc
-from . import di_futures as dif
+from .. import calendar as cl
+from . import core as cr
 
 
 def get_old_expiration_date(
@@ -66,13 +66,13 @@ def get_old_expiration_date(
         ExpirationDate = pd.Timestamp(year, month, 1)
         # Adjust to the next business day when ExpirationDate date is a weekend or a holiday
         # Must use the old holiday calendar, since this type of contract code was used until 2006
-        return brc.offset_bdays(ExpirationDate, offset=0, holiday_list="old")
+        return cl.offset_bdays(ExpirationDate, offset=0, holiday_list="old")
 
     except (KeyError, ValueError):
         return pd.NaT  # type: ignore
 
 
-def get_raw_di(trade_date: Timestamp) -> DataFrame:
+def _get_raw_di(trade_date: Timestamp) -> DataFrame:
     """
     Internal function to fetch raw DI futures data from B3 for a specific trade date.
 
@@ -120,7 +120,7 @@ def get_raw_di(trade_date: Timestamp) -> DataFrame:
         return pd.DataFrame()
 
 
-def convert_prices_to_rates(prices: Series, bd: Series) -> Series:
+def _convert_prices_to_rates(prices: Series, bd: Series) -> Series:
     """
     Internal function to convert DI futures prices to rates.
 
@@ -137,7 +137,7 @@ def convert_prices_to_rates(prices: Series, bd: Series) -> Series:
     return 100 * rates
 
 
-def convert_prices_in_older_contracts(df: DataFrame) -> DataFrame:
+def _convert_prices_in_older_contracts(df: DataFrame) -> DataFrame:
     # Prior to 01/01/2002, prices were not converted to rates
     convert_cols = [
         "FirstRate",
@@ -149,7 +149,7 @@ def convert_prices_in_older_contracts(df: DataFrame) -> DataFrame:
         "LastAskRate",
     ]
     for col in convert_cols:
-        df[col] = convert_prices_to_rates(df[col], df["BDToExpiration"])
+        df[col] = _convert_prices_to_rates(df[col], df["BDToExpiration"])
 
     # Invert low and high prices
     df["MinRate"], df["MaxRate"] = df["MaxRate"], df["MinRate"]
@@ -157,7 +157,7 @@ def convert_prices_in_older_contracts(df: DataFrame) -> DataFrame:
     return df
 
 
-def process_di(df: DataFrame, trade_date: Timestamp) -> DataFrame:
+def _process_di(df: DataFrame, trade_date: Timestamp) -> DataFrame:
     """
     Internal function to process and transform raw DI futures data.
 
@@ -205,9 +205,9 @@ def process_di(df: DataFrame, trade_date: Timestamp) -> DataFrame:
             get_old_expiration_date, args=(trade_date,)
         )
     else:
-        df["ExpirationDate"] = df["ExpirationCode"].apply(dif.get_expiration_date)
+        df["ExpirationDate"] = df["ExpirationCode"].apply(cr.get_expiration_date)
 
-    df["BDToExpiration"] = brc.count_bdays(trade_date, df["ExpirationDate"])
+    df["BDToExpiration"] = cl.count_bdays(trade_date, df["ExpirationDate"])
     # Convert to nullable integer, since other columns use this data type
     df["BDToExpiration"] = df["BDToExpiration"].astype(pd.Int64Dtype())
     # Remove expired contracts
@@ -229,9 +229,9 @@ def process_di(df: DataFrame, trade_date: Timestamp) -> DataFrame:
 
     # Prior to 17/01/2002 (incluive), prices were not converted to rates
     if trade_date <= pd.Timestamp("2002-01-17"):
-        df = convert_prices_in_older_contracts(df)
+        df = _convert_prices_in_older_contracts(df)
 
-    df["SettlementRate"] = convert_prices_to_rates(
+    df["SettlementRate"] = _convert_prices_to_rates(
         df["SettlementPrice"], df["BDToExpiration"]
     )
 
@@ -289,7 +289,7 @@ def get_di(trade_date: Timestamp, return_raw: bool = False) -> DataFrame:
         - OpenContracts: number of open contracts at the start of the trading day.
         - closed_contracts: number of closed contracts at the end of the trading day.
     """
-    df_raw = get_raw_di(trade_date)
+    df_raw = _get_raw_di(trade_date)
     if return_raw:
         return df_raw
-    return process_di(df_raw, trade_date)
+    return _process_di(df_raw, trade_date)

pyield-0.4.0/pyield/di_xml.py → pyield-0.5.0/pyield/di/xml.py

@@ -7,11 +7,11 @@ import pandas as pd
 from pandas import Timestamp, DataFrame
 from lxml import etree
 
-from . import di_futures as dif
-from . import br_calendar as brc
+from . import core as cr
+from .. import calendar as cd
 
 
-def get_file_from_url(trade_date: Timestamp, source_type: str) -> io.BytesIO:
+def _get_file_from_url(trade_date: Timestamp, source_type: str) -> io.BytesIO:
     """
     Types of XML files available:
     Full Price Report (all assets)
@@ -39,7 +39,7 @@ def get_file_from_url(trade_date: Timestamp, source_type: str) -> io.BytesIO:
     return io.BytesIO(response.content)
 
 
-def extract_xml_from_zip(zip_file: io.BytesIO) -> io.BytesIO:
+def _extract_xml_from_zip(zip_file: io.BytesIO) -> io.BytesIO:
     # First, read the outer file
     with zipfile.ZipFile(zip_file, "r") as outer_zip:
         outer_file_name = outer_zip.namelist()[0]
@@ -58,7 +58,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[dict]:
+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
     )
@@ -120,7 +120,7 @@ def extract_di_data_from_xml(xml_file: io.BytesIO) -> list[dict]:
     return di_data
 
 
-def create_df_from_di_data(di1_data: list) -> DataFrame:
+def _create_df_from_di_data(di1_data: list) -> DataFrame:
     # Criar um DataFrame com os dados coletados
     df = pd.DataFrame(di1_data)
 
@@ -129,7 +129,7 @@ def create_df_from_di_data(di1_data: list) -> DataFrame:
     return pd.read_csv(file, dtype_backend="numpy_nullable")
 
 
-def filter_and_order_pr_df(df: DataFrame) -> DataFrame:
+def _filter_and_order_pr_df(df: DataFrame) -> DataFrame:
     selected_columns = [
         "TradDt",
         "TckrSymb",
@@ -165,7 +165,7 @@ def filter_and_order_pr_df(df: DataFrame) -> DataFrame:
     return df[selected_columns]
 
 
-def filter_and_order_sprd_df(df: DataFrame) -> DataFrame:
+def _filter_and_order_sprd_df(df: DataFrame) -> DataFrame:
     cols = [
         "TradDt",
         "TckrSymb",
@@ -187,7 +187,7 @@ def filter_and_order_sprd_df(df: DataFrame) -> DataFrame:
     return df[cols]
 
 
-def standardize_column_names(df: DataFrame) -> DataFrame:
+def _standardize_column_names(df: DataFrame) -> DataFrame:
     rename_dict = {
         "TradDt": "TradeDate",
         "TckrSymb": "Ticker",
@@ -224,15 +224,15 @@ def standardize_column_names(df: DataFrame) -> DataFrame:
     return df.rename(columns=rename_dict)
 
 
-def process_di_df(df_raw: DataFrame) -> DataFrame:
+def _process_di_df(df_raw: DataFrame) -> DataFrame:
     df = df_raw.copy()
     # Convert to datetime64[ns] since it is pandas default type for timestamps
     df["TradDt"] = df["TradDt"].astype("datetime64[ns]")
 
-    expiration = df["TckrSymb"].str[3:].apply(dif.get_expiration_date)
+    expiration = df["TckrSymb"].str[3:].apply(cr.get_expiration_date)
     df.insert(2, "ExpirationDate", expiration)
 
-    business_days = brc.count_bdays(df["TradDt"], df["ExpirationDate"])
+    business_days = cd.count_bdays(df["TradDt"], df["ExpirationDate"])
     df.insert(3, "BDToExpiration", business_days)
 
     # Convert to nullable integer, since other columns use this data type
@@ -245,29 +245,29 @@ def process_di_df(df_raw: DataFrame) -> DataFrame:
 
 
 def get_di(trade_date: Timestamp, source_type: str, return_raw: bool) -> DataFrame:
-    zip_file = get_file_from_url(trade_date, source_type)
+    zip_file = _get_file_from_url(trade_date, source_type)
 
-    xml_file = extract_xml_from_zip(zip_file)
+    xml_file = _extract_xml_from_zip(zip_file)
 
-    di_data = extract_di_data_from_xml(xml_file)
+    di_data = _extract_di_data_from_xml(xml_file)
 
-    df_raw = create_df_from_di_data(di_data)
+    df_raw = _create_df_from_di_data(di_data)
     if return_raw:
         return df_raw
 
     # Remove unnecessary columns
     if source_type == "b3":
-        df_di = filter_and_order_pr_df(df_raw)
+        df_di = _filter_and_order_pr_df(df_raw)
     elif source_type == "b3s":
-        df_di = filter_and_order_sprd_df(df_raw)
+        df_di = _filter_and_order_sprd_df(df_raw)
     else:
         raise ValueError("Invalid source type. Must be 'b3' or 'b3s'.")
 
     # Process and transform data
-    df_di = process_di_df(df_di)
+    df_di = _process_di_df(df_di)
 
     # Standardize column names
-    df_di = standardize_column_names(df_di)
+    df_di = _standardize_column_names(df_di)
 
     return df_di
 
@@ -280,28 +280,28 @@ def read_di(file_path: Path, return_raw: bool = False) -> DataFrame:
         else:
             raise FileNotFoundError(f"No file found at {file_path}.")
 
-        xml_file = extract_xml_from_zip(zip_file)
+        xml_file = _extract_xml_from_zip(zip_file)
 
-        di_data = extract_di_data_from_xml(xml_file)
+        di_data = _extract_di_data_from_xml(xml_file)
 
-        df_raw = create_df_from_di_data(di_data)
+        df_raw = _create_df_from_di_data(di_data)
         if return_raw:
             return df_raw
 
         # Filename examples: PR231228.zip or SPRD240216.zip
         file_stem = file_path.stem
         if "PR" in file_stem:
-            df_di = filter_and_order_pr_df(df_raw)
+            df_di = _filter_and_order_pr_df(df_raw)
         elif "SPRD" in file_stem:
-            df_di = filter_and_order_sprd_df(df_raw)
+            df_di = _filter_and_order_sprd_df(df_raw)
         else:
             raise ValueError("Filename must start with 'PR' or 'SPRD'.")
 
         # Process and transform data
-        df_di = process_di_df(df_di)
+        df_di = _process_di_df(df_di)
 
         # Standardize column names
-        df_di = standardize_column_names(df_di)
+        df_di = _standardize_column_names(df_di)
 
         return df_di
 

pyield-0.5.0/pyield/holidays/__init__.py

@@ -0,0 +1,3 @@
+from .core import BrHolidays
+
+__all__ = ["BrHolidays"]

{pyield-0.4.0 → pyield-0.5.0}/pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
     "lxml",
 ]
 dynamic = []
-version = "0.4.0"
+version = "0.5.0"
 
 [project.license]
 file = "LICENSE"

{pyield-0.4.0 → pyield-0.5.0}/tests/test_br_calendar.py

@@ -1,14 +1,14 @@
 import pandas as pd
 import numpy as np
 
-from pyield import br_calendar as brc
+from pyield import calendar as cl
 
 
 def test_count_bdays_1():
     start = "2023-01-01"
     end = "2023-01-08"
     # 01/01/2023 is a Sunday and a holiday
-    assert brc.count_bdays(start, end) == 5
+    assert cl.count_bdays(start, end) == 5
 
 
 def test_count_bdays_2():
@@ -16,30 +16,30 @@ def test_count_bdays_2():
     end = "2024-01-02"
     # 25/12/2023 is a holiday
     # 01/01/2024 is a holiday
-    assert brc.count_bdays(start, end) == 10
+    assert cl.count_bdays(start, end) == 10
 
 
 def test_count_bdays_with_series():
     start = "2023-01-01"
     end = pd.Series(["2023-01-08", "2023-01-22"])
     # Assuming no holidays in these periods
-    assert np.array_equal(brc.count_bdays(start, end), np.array([5, 15]))
+    assert np.array_equal(cl.count_bdays(start, end), np.array([5, 15]))
 
 
 def test_count_bdays_negative_count():
     start = "2023-01-08"
     end = "2023-01-01"
     # Negative count expected
-    assert brc.count_bdays(start, end) == -5
+    assert cl.count_bdays(start, end) == -5
 
 
 def test_count_bdays_new_holiday_list():
     start = "2024-11-20"  # Zumbi Nacional Day
     end = "2024-11-21"
-    assert brc.count_bdays(start, end) == 0
+    assert cl.count_bdays(start, end) == 0
 
 
 def test_count_bdays_old_holiday_list():
     start = "2020-11-20"  # Was not a holiday in 2020
     end = "2020-11-21"
-    assert brc.count_bdays(start, end) == 1
+    assert cl.count_bdays(start, end) == 1

{pyield-0.4.0 → pyield-0.5.0}/tests/test_di.py

@@ -1,14 +1,14 @@
 import pandas as pd
 import pytest
 
-from pyield import di_futures as dif
-from pyield import di_web as diw
+from pyield.di import core as cr
+from pyield.di import web as wb
 
 
 def test_valid_old_contract_code1():
     expiration_code = "JAN3"  # Valid contract code
     trade_date = pd.Timestamp("2001-05-21")
-    result = diw.get_old_expiration_date(expiration_code, trade_date)
+    result = wb.get_old_expiration_date(expiration_code, trade_date)
     contract_expiration = pd.Timestamp("2003-01-02")
     assert result == contract_expiration
 
@@ -16,7 +16,7 @@ def test_valid_old_contract_code1():
 def test_valid_old_contract_code2():
     expiration_code = "JAN3"  # Valid contract code
     trade_date = pd.Timestamp("1990-01-01")
-    result = diw.get_old_expiration_date(expiration_code, trade_date)
+    result = wb.get_old_expiration_date(expiration_code, trade_date)
     contract_expiration = pd.Timestamp("1993-01-04")
     assert result == contract_expiration
 
@@ -25,13 +25,13 @@ def test_invalid_old_contract_code():
     expiration_code = "J3"  # Invalid contract code
     trade_date = pd.Timestamp("2001-01-02")
     # Must return NaT
-    result = diw.get_old_expiration_date(expiration_code, trade_date)
+    result = wb.get_old_expiration_date(expiration_code, trade_date)
     assert pd.isnull(result)
 
 
 def test_new_contract_code():
     expiration_code = "F23"  # Valid contract code
-    result = dif.get_expiration_date(expiration_code)
+    result = cr.get_expiration_date(expiration_code)
     contract_expiration = pd.Timestamp("2023-01-02")
     assert result == contract_expiration
 
@@ -43,7 +43,7 @@ def test_settlement_rate_with_old_holiday_list():
     }
 
     # 22-12-2023 is before the new holiday calendar
-    df = dif.get_di(trade_date="2023-12-22")
+    df = cr.get_di(trade_date="2023-12-22")
     expiration_codes = list(settlement_rates.keys())  # noqa: F841
     result = df.query("ExpirationCode in @expiration_codes")["SettlementRate"].to_list()
     assert result == list(settlement_rates.values())
@@ -68,7 +68,7 @@ def test_settlement_rates_with_current_holiday_list():
         "F33": 0.10331,
     }
 
-    df = dif.get_di(trade_date="2023-12-26")
+    df = cr.get_di(trade_date="2023-12-26")
     expiration_codes = list(settlement_rates.keys())  # noqa: F841
     results = df.query("ExpirationCode in @expiration_codes")[
         "SettlementRate"
@@ -79,4 +79,4 @@ def test_settlement_rates_with_current_holiday_list():
 def test_non_business_day():
     non_business_day = "2023-12-24"
     with pytest.raises(ValueError):
-        dif.get_di(trade_date=non_business_day)
+        cr.get_di(trade_date=non_business_day)

pyield-0.4.0/pyield/__about__.py

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