PYield 0.36.2__tar.gz → 0.36.4__tar.gz

{pyield-0.36.2 → pyield-0.36.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PYield
-Version: 0.36.2
+Version: 0.36.4
 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.36.4/pyield/__about__.py

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

{pyield-0.36.2 → pyield-0.36.4}/pyield/anbima/imaq.py

@@ -104,7 +104,7 @@ def _process_df(df: pd.DataFrame) -> pd.DataFrame:
             df[col] = pd.to_numeric(df[col], errors="coerce")
 
         # Remove the thousands unit from numeric columns
-        df[col] *= (1000 * df[col]).astype("Int64")
+        df[col] = (1000 * df[col]).astype("Int64")
 
     return df
 

{pyield-0.36.2 → pyield-0.36.4}/pyield/bc/auction.py

@@ -195,8 +195,18 @@ def _get_ptax_df(start_date: pd.Timestamp | None = None) -> pd.DataFrame:
 
 def _add_usd_dv01(df: pd.DataFrame) -> pd.DataFrame:
     ptax_start_date = df["Date"].min()
-    df_ptax = _get_ptax_df(start_date=ptax_start_date)
-    df = pd.merge_asof(left=df, right=df_ptax)
+
+    # 1. Garanta que o DataFrame 'right' esteja ordenado pela chave de merge.
+    df_ptax = (
+        _get_ptax_df(start_date=ptax_start_date)
+        .sort_values(by="Date")
+        .reset_index(drop=True)
+    )
+
+    # 2. Garanta que o DataFrame 'left' esteja ordenado pela chave de merge.
+    df = df.sort_values(by="Date").reset_index(drop=True)
+    df = pd.merge_asof(left=df, right=df_ptax, on="Date", direction="backward")
+
     dv01_cols = [c for c in df.columns if c.startswith("DV01")]
     for col in dv01_cols:
         df[f"{col}USD"] = df[col] / df["PTAX"]

{pyield-0.36.2 → pyield-0.36.4}/pyield/bc/bcdata.py

@@ -15,7 +15,9 @@ Implementation Notes:
 """
 
 import logging
+from datetime import datetime
 from enum import Enum
+from functools import lru_cache
 from urllib.error import HTTPError
 
 import pandas as pd
@@ -30,6 +32,12 @@ BASE_URL = "https://api.bcb.gov.br/dados/serie/bcdata.sgs."
 DECIMAL_PLACES_ANNUALIZED = 4  # 2 decimal places in percentage format
 DECIMAL_PLACES_DAILY = 8  # 6 decimal places in percentage format
 
+# 404 Not Found error code for resource not found in the API
+ERROR_CODE_NOT_FOUND = 404
+
+# 400 Bad Request error code for invalid requests
+ERROR_CODE_BAD_REQUEST = 400
+
 
 class BCSerie(Enum):
     """Enum para as séries disponíveis no Banco Central."""
@@ -70,68 +78,130 @@ def _build_download_url(
     return api_url
 
 
+@lru_cache(maxsize=128)
 @default_retry
-def _fetch_data_from_url(
-    serie: BCSerie, start: DateScalar | None = None, end: DateScalar | None = None
+def _cached_fetch_worker(
+    serie: BCSerie,
+    start: DateScalar | None,
+    end: DateScalar | None,
+    hourly_timestamp_hash: str,
 ) -> pd.DataFrame:
     """
-    Fetches data from the Central Bank API with retry mechanism.
-
-    Args:
-        serie: The series enum to fetch
-        start: The start date for the data to fetch
-        end: The end date for the data
-
-    Returns:
-        DataFrame with the requested data
-
-    Raises:
-        HTTPError: If the resource is not found (404) or other HTTP error
-        Various exceptions: For other errors after retry attempts are exhausted
+    Worker function that fetches data from the API.
+    This function is decorated with lru_cache. The hourly_timestamp_hash argument
+    is a string in 'yymmddHH' format, used to invalidate the cache hourly.
     """
     api_url = _build_download_url(serie, start, end)
+    logger.debug(
+        f"CACHE MISS for hash {hourly_timestamp_hash}. Fetching from URL: {api_url}"
+    )
 
     try:
         response = requests.get(api_url, timeout=30)
-        response.raise_for_status()  # Raise exception for 4XX/5XX status codes
+        response.raise_for_status()
         data = response.json()
 
         if not data:
             logger.warning(f"No data available for the requested period: {api_url}")
             return pd.DataFrame()
 
-        # Convert JSON to DataFrame
-        df = pd.DataFrame(data)
-
-        if df.empty or "valor" not in df.columns:
-            logger.warning(f"No data available for the requested period: {api_url}")
-            return pd.DataFrame()
-
-        # Process the dataframe
         df = pd.DataFrame(data, dtype="string")
         df = df.rename(columns={"data": "Date", "valor": "Value"})
-
         df["Date"] = pd.to_datetime(df["Date"], format="%d/%m/%Y")
-        # Value is in percentage format, so divide by 100
         df["Value"] = (df["Value"].astype("Float64")) / 100
 
-        return df
+        # Return a copy to ensure the cached object is not mutated externally
+        return df.copy()
+
     except HTTPError as e:
-        if e.code == 404:  # noqa
+        if e.response.status_code == ERROR_CODE_NOT_FOUND:
             logger.warning(f"Resource not found (404): {api_url}")
             return pd.DataFrame()
+        if (
+            e.response.status_code == ERROR_CODE_BAD_REQUEST
+            and "janela de consulta" in e.response.text
+        ):
+            logger.error(
+                "API request exceeded the 10-year limit. "
+                "This should have been handled by the chunking logic. URL: %s",
+                api_url,
+            )
         else:
             logger.error(f"HTTP error accessing Central Bank API: {e}")
-            raise
-    except pd.errors.ParserError as e:
-        # For parsing errors, log and re-raise to allow retry
-        logger.warning(f"CSV parsing error (possibly HTML or invalid format): {e}")
         raise
     except Exception as e:
         logger.error(f"Error fetching data from Central Bank API: {e}")
         raise
 
 
+def _fetch_single_request(
+    serie: BCSerie, start: DateScalar | None = None, end: DateScalar | None = None
+) -> pd.DataFrame:
+    """
+    Wrapper that provides an hourly time-based cache invalidation for the worker.
+    It computes a readable hash based on the current hour ('yymmddHH') and
+    passes it to the cached worker function.
+    """
+    hourly_timestamp_hash = datetime.now().strftime("%y%m%d%H")
+    return _cached_fetch_worker(serie, start, end, hourly_timestamp_hash)
+
+
+def _fetch_data_from_url(
+    serie: BCSerie, start: DateScalar | None = None, end: DateScalar | None = None
+) -> pd.DataFrame:
+    """
+    Orchestrates fetching data from the Central Bank API, handling requests longer
+    than 10 years by splitting them into smaller chunks using pandas DateOffset.
+
+    Args:
+        serie: The series enum to fetch
+        start: The start date for the data to fetch
+        end: The end date for the data
+
+    Returns:
+        DataFrame with the requested data
+    """
+    # 1. Converter datas usando a função auxiliar existente e o pandas
+    start_date = convert_input_dates(start) if start else None
+    # Se a data final não for fornecida, usar a data de hoje para o cálculo do período
+    end_date = convert_input_dates(end) if end else pd.to_datetime("today").normalize()
+
+    # Se não houver data de início, a API já limita a 10 anos. Chamada direta é segura.
+    if not start_date:
+        return _fetch_single_request(serie, start, end)
+
+    # 2. Verificar se o período é maior que 10 anos usando pd.DateOffset
+    if end_date < start_date + pd.DateOffset(years=10):
+        return _fetch_single_request(serie, start_date, end_date)
+
+    # 3. Se for maior, quebrar em pedaços (chunking)
+    logger.info("Date range exceeds 10 years. Fetching data in chunks.")
+    all_dfs = []
+    current_start = start_date
+
+    while current_start < end_date:
+        # Fim do chunk é 10 anos à frente, menos 1 dia.
+        chunk_end = current_start + pd.DateOffset(years=10) - pd.DateOffset(days=1)
+
+        # Garantir que o fim do chunk não ultrapasse a data final solicitada
+        chunk_end = min(chunk_end, end_date)
+
+        # Buscar os dados para este chunk
+        df_chunk = _fetch_single_request(serie, current_start, chunk_end)
+        if not df_chunk.empty:
+            all_dfs.append(df_chunk)
+
+        # Preparar o início do próximo chunk
+        current_start = chunk_end + pd.DateOffset(days=1)
+
+    if not all_dfs:
+        return pd.DataFrame()
+
+    # 4. Concatenar todos os DataFrames e retornar o resultado
+    final_df = pd.concat(all_dfs, ignore_index=True)
+    return final_df
+
+
 def selic_over_series(
     start: DateScalar | None = None, end: DateScalar | None = None
 ) -> pd.DataFrame:

pyield-0.36.2/pyield/__about__.py

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