lambda-risk 0.0.0.4__tar.gz → 0.0.0.6__tar.gz

{lambda_risk-0.0.0.4 → lambda_risk-0.0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda_risk
-Version: 0.0.0.4
+Version: 0.0.0.6
 Description-Content-Type: text/markdown
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: requests>=2.32.3
@@ -10,6 +10,7 @@ Requires-Dist: PyQuantimClient
 Requires-Dist: holidays
 Requires-Dist: pyarrow
 Requires-Dist: fastparquet
+Requires-Dist: bcchapi
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: requires-dist

{lambda_risk-0.0.0.4 → lambda_risk-0.0.0.6}/lambda_risk/client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import mimetypes
 import os
 import tempfile
 import time
@@ -12,8 +13,8 @@ import requests
 
 @dataclass
 class Config:
-    base_url: str
-    token: str
+    base_url: str = os.getenv("LAMBDA_API_URL")
+    token: str = os.getenv("LAMBDA_API_TOKEN")
     timeout: int = 120
     poll_seconds: int = 3
     max_polls: int = 120
@@ -354,9 +355,9 @@ class FrameworkRiesgo(Config):
 
 
 class StorageFiles(Config):
-    def get_file_url(self, bucket: str, path: str, log: bool = False) -> dict[str, Any]:
+    def get_file_url(self, bucket: str, path: str, *, admin_password: str, log: bool = False) -> dict[str, Any]:
         started_at = time.perf_counter()
-        data = self._post("files/signed-url", {"bucket": bucket, "path": path})
+        data = self._post("files/signed-url", {"bucket": bucket, "path": path, "admin_password": admin_password})
         elapsed = self._format_elapsed(time.perf_counter() - started_at)
         self._print(
             f"file_signed_url={elapsed} | bucket={bucket} | path={path} | size_bytes={data['size_bytes']}",
@@ -364,14 +365,40 @@ class StorageFiles(Config):
         )
         return data
 
+    def get_upload_url(
+        self,
+        bucket: str,
+        path: str,
+        *,
+        admin_password: str,
+        content_type: Optional[str] = None,
+        log: bool = False,
+    ) -> dict[str, Any]:
+        started_at = time.perf_counter()
+        payload = {
+            "bucket": bucket,
+            "path": path,
+            "admin_password": admin_password,
+            "content_type": content_type or "application/octet-stream",
+        }
+        data = self._post("files/upload-url", payload)
+        elapsed = self._format_elapsed(time.perf_counter() - started_at)
+        self._print(
+            f"file_upload_url={elapsed} | bucket={bucket} | path={path} | content_type={data['content_type']}",
+            log,
+        )
+        return data
+
     def download_file(
         self,
         bucket: str,
         path: str,
+        *,
+        admin_password: str,
         destination: str | os.PathLike = ".",
         log: bool = False,
     ) -> Path:
-        file_info = self.get_file_url(bucket, path, log=log)
+        file_info = self.get_file_url(bucket, path, admin_password=admin_password, log=log)
         destination_path = Path(destination)
         if destination_path.suffix:
             output_path = destination_path
@@ -394,3 +421,40 @@ class StorageFiles(Config):
             log,
         )
         return output_path
+
+    def upload_file(
+        self,
+        source: str | os.PathLike,
+        bucket: str,
+        path: str,
+        *,
+        admin_password: str,
+        content_type: Optional[str] = None,
+        log: bool = False,
+    ) -> dict[str, Any]:
+        source_path = Path(source)
+        detected_content_type = content_type or mimetypes.guess_type(source_path.name)[0] or "application/octet-stream"
+        file_info = self.get_upload_url(
+            bucket,
+            path,
+            admin_password=admin_password,
+            content_type=detected_content_type,
+            log=log,
+        )
+
+        started_at = time.perf_counter()
+        with source_path.open("rb") as file_obj:
+            response = requests.put(
+                file_info["signed_url"],
+                data=file_obj,
+                headers=file_info["headers"],
+                timeout=600,
+            )
+            response.raise_for_status()
+
+        elapsed = self._format_elapsed(time.perf_counter() - started_at)
+        self._print(
+            f"file_upload={elapsed} | gs_uri={file_info['gs_uri']} | mb={source_path.stat().st_size / (1024 * 1024):.2f}",
+            log,
+        )
+        return file_info

lambda_risk-0.0.0.6/lambda_risk/risk.py

@@ -0,0 +1,1051 @@
+import os
+import pandas as pd
+import numpy as np
+from scipy.stats import norm
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+from .client import Datamart, FrameworkRiesgo
+import bcchapi
+
+@dataclass
+class ExpostRisk:
+
+    def ewma_varianza(self,returns:pd.DataFrame,factor:float) -> float:
+        pass
+
+    def decay_varianza(self,returns:pd.DataFrame,factor:float) -> float:
+        pass
+    
+    def volatilidad(self,returns:pd.DataFrame,ewma:bool=False, decay:bool=False) -> float:
+        pass
+
+    def value_at_risk(self, confidence_level:float, sigma:float, mu:float=0.0) -> float:
+        pass
+
+    def tracking_error(self, ret_target:pd.DataFrame, ret_bmk:pd.DataFrame, ewma:bool=False, decay:bool=False) -> float:
+        pass
+
+
+@dataclass
+class RetornosBrutos:
+    end_date : str
+    agf_target : str 
+    year : str
+    bmk_categ : str 
+    run_target : Optional[str] = None
+    dtd : bool = True
+    wtw : bool = True
+    mtm : bool = True
+    rolling_window : Optional[list[str]] = None
+    drop_weekends : bool = True
+    len_data : str = '6Y'
+    moneda : str = 'original'
+    usd : bool = False
+    decay_factor : Optional[list[float]] = None
+    result : Dict[str, pd.DataFrame] = None
+    bc_user : str = None
+    bc_pwd : str = None
+
+    def __post_init__(self):
+        # clientes
+        self.client_datamart = Datamart()
+        self.client_framework = FrameworkRiesgo()
+
+        # Banco Central
+        if self.usd:
+            if self.bc_user is None:
+                try:
+                    self.bc_user = os.getenv("BCCH_API_USER")
+                except KeyError:
+                    raise ValueError("BCCH_API_USER environment variable not set")
+            if self.bc_pwd is None:
+                try:
+                    self.bc_pwd = os.getenv("BCCH_API_PWD")
+                except KeyError:
+                    raise ValueError("BCCH_API_PWD environment variable not set")
+            self.API_BCCH_USER = self.bc_user
+            self.API_BCCH_PWD = self.bc_pwd
+            self.usd_data = self.descargar_usd()
+
+        # vigente
+        self.fondos_vigentes = self.vigente()
+
+        # target
+        if self.run_target is None:
+            self.runs_target = self.target()
+
+        # competidores
+        self.comp = self.competidores()
+        self.runs_competidores = self.comp['COMPETIDOR'].tolist()
+
+        # datos
+        self.raw_data = self.load_data()
+        self.result = self.calculate_returns()
+
+    def vigente(self):
+        df : pd.DataFrame = self.client_datamart.export_fondos(
+        ignorar_cambio_nombre=True,
+        fecha_corte=self.end_date
+        )
+        # print("[DEBUG] Fondos vigentes exportados\n",df.dtypes)
+        df["FECHA_MAX"] = pd.to_datetime(df['FECHA_MAX'])
+        df["FECHA_MIN"] = pd.to_datetime(df['FECHA_MIN'])
+        df['VIGENTE'] = df.apply(lambda x: 1 if x['FECHA_MAX']==pd.to_datetime(self.end_date) else 0, axis=1)
+        return df
+    
+    def target(self):
+        df = self.fondos_vigentes[(self.fondos_vigentes['ADMINISTRADORA'] == self.agf_target) & (self.fondos_vigentes['VIGENTE'] == 1)]
+        runs : list = df['RUN'].tolist()
+        return runs
+    
+    def competidores(self):
+        df : pd.DataFrame = self.client_framework.export_benchmarks(
+            year=self.year,
+            categoria=self.bmk_categ
+        )
+        df = df[[f"RUN_{self.agf_target}", "COMPETIDOR"]].merge(
+            self.fondos_vigentes[['RUN', 'ADMINISTRADORA', 'FONDO', 'FECHA_MIN', 'FECHA_MAX', 'VIGENTE']],left_on="COMPETIDOR", right_on="RUN", how="left")
+        df = df.rename(columns={f"RUN_{self.agf_target}":"RUN_TARGET"})
+
+        return df
+    
+    def load_data(self):
+        lst_runs = list(set(self.runs_target + self.runs_competidores))
+        start_date = pd.to_datetime(self.end_date) - pd.DateOffset(years=int(self.len_data.replace("Y", "")))
+        start_date = start_date.strftime("%Y-%m-%d")
+        # print("[DEBUG] lista de runs a cargar: \n", lst_runs)
+        df : pd.DataFrame = self.client_datamart.export_vc(
+        fecha_inicio=start_date,
+        fecha_fin=self.end_date,
+        moneda=self.moneda,
+        bruto=True,
+        runs = lst_runs,
+        )
+
+        if self.drop_weekends:
+            df['FECHA'] = pd.to_datetime(df['FECHA'])
+            df = df[df['FECHA'].dt.weekday < 5].copy()
+        if self.usd:
+            df = pd.concat([df, self.sabana_usd(df.columns)], ignore_index=True)
+        return df
+
+    def sabana_usd(self, columns):
+        usd = self.usd_data.copy()
+        if 'FECHA' not in usd.columns:
+            usd = usd.reset_index()
+            usd = usd.rename(columns={usd.columns[0]: 'FECHA'})
+        usd['FECHA'] = pd.to_datetime(usd['FECHA'])
+
+        value_col = 'USDCLP' if 'USDCLP' in usd.columns else usd.columns.difference(['FECHA'])[0]
+        usd = usd[['FECHA', value_col]].rename(columns={value_col: 'VALORCUOTA'})
+        usd['VALORCUOTA'] = pd.to_numeric(usd['VALORCUOTA'], errors='coerce')
+        usd = usd.sort_values('FECHA')
+        usd['VALORCUOTA'] = usd['VALORCUOTA'].ffill()
+        usd['RUN'] = 'USDCLP'
+
+        start_date = pd.to_datetime(self.end_date) - pd.DateOffset(years=int(self.len_data.replace("Y", "")))
+        end_date = pd.to_datetime(self.end_date)
+        usd = usd[(usd['FECHA'] >= start_date) & (usd['FECHA'] <= end_date)]
+        if self.drop_weekends:
+            usd = usd[usd['FECHA'].dt.weekday < 5]
+
+        return usd.reindex(columns=columns)
+    
+    def valores_cuota(self):
+        df = self.raw_data.copy()
+        df['FECHA'] = pd.to_datetime(df['FECHA'])
+        return df.pivot_table(
+            index='FECHA',
+            columns='RUN',
+            values='VALORCUOTA',
+            aggfunc='last'
+        ).sort_index()
+    
+    def ajustar_fecha_min(self, returns: pd.DataFrame):
+        fecha_min = self.fondos_vigentes[['RUN', 'FECHA_MIN']].dropna().copy()
+        fecha_min['FECHA_MIN'] = pd.to_datetime(fecha_min['FECHA_MIN'])
+        fecha_min_by_run = fecha_min.set_index(fecha_min['RUN'].astype(str))['FECHA_MIN'].to_dict()
+
+        returns = returns.copy()
+        returns.index = pd.to_datetime(returns.index)
+        for run in returns.columns:
+            min_date = fecha_min_by_run.get(str(run))
+            if min_date is not None:
+                returns.loc[returns.index < min_date, run] = None
+        return returns
+    
+    def retorno_periodo(self, valores_cuota: pd.DataFrame, periods: int):
+        returns = valores_cuota.pct_change(periods=periods)
+        end_date = pd.to_datetime(self.end_date)
+        anchor_pos = returns.index.searchsorted(end_date, side='right') - 1
+        if anchor_pos < 0:
+            return returns.iloc[0:0]
+
+        positions = np.arange(anchor_pos, -1, -periods)
+        positions = np.sort(positions)
+        return returns.iloc[positions]
+    
+    def retorno_rolling(self, valores_cuota: pd.DataFrame, window: int):
+        return valores_cuota.pct_change(periods=window)
+    
+    def decay_key(self, factor: float):
+        factor_pct = factor * 100
+        if factor_pct.is_integer():
+            return f'DECAY{int(factor_pct)}'
+        return f'DECAY{str(factor_pct).replace(".", "_")}'
+    
+    def pesos_decay(self, index: pd.Index, factor: float):
+        end_date = pd.to_datetime(self.end_date)
+        index = pd.to_datetime(index)
+        weights = pd.Series(index=index, dtype=float)
+        anchor_pos = index.searchsorted(end_date, side='right') - 1
+        if anchor_pos < 0:
+            return weights
+
+        positions = np.arange(anchor_pos, -1, -1)
+        age = anchor_pos - positions
+        weights.iloc[positions] = (1 - factor) * np.power(factor, age)
+        return weights
+    
+    def agregar_decay(self, returns: pd.DataFrame):
+        returns = returns.copy()
+        if self.decay_factor is not None:
+            for factor in self.decay_factor:
+                factor = float(factor)
+                returns[self.decay_key(factor)] = self.pesos_decay(returns.index, factor=factor)
+        return returns
+    
+    def calculate_returns(self):
+        if not any([self.dtd, self.wtw, self.mtm]) and self.rolling_window is None:
+            return None
+
+        valores_cuota = self.valores_cuota()
+        selected_returns = {
+            'dtd': self.dtd,
+            'wtw': self.wtw,
+            'mtm': self.mtm,
+        }
+
+        result = {}
+        if selected_returns['dtd']:
+            result['dtd'] = self.agregar_decay(self.ajustar_fecha_min(self.retorno_periodo(valores_cuota, periods=1)))
+        if selected_returns['wtw']:
+            result['wtw'] = self.agregar_decay(self.ajustar_fecha_min(self.retorno_periodo(valores_cuota, periods=5)))
+        if selected_returns['mtm']:
+            result['mtm'] = self.agregar_decay(self.ajustar_fecha_min(self.retorno_periodo(valores_cuota, periods=20)))
+        if self.rolling_window is not None:
+            for window in self.rolling_window:
+                window = int(window)
+                result[f'ROLL{window}'] = self.agregar_decay(self.ajustar_fecha_min(self.retorno_rolling(valores_cuota, window=window)))
+        return result
+    
+    def descargar_usd(self,serie:str="F073.TCO.PRE.Z.D", nombre:str="USDCLP"):
+        bc = bcchapi.Siete(self.bc_user, self.bc_pwd)
+        df_descarga = bc.cuadro(series=serie, nombres=[nombre])
+        return df_descarga
+
+@dataclass
+class MetricasExpost:
+    year : str
+    data : Dict[str, pd.DataFrame] = field(default_factory=dict)
+    fondos_vigentes : pd.DataFrame = field(default_factory=pd.DataFrame)
+    target : Optional[str] = None
+    decays : Optional[List[float]] = None
+    rangos : Optional[Dict[str, int]] = None
+    moneda_default : str = "CLP"
+    result : pd.DataFrame = field(default_factory=pd.DataFrame)
+
+    def __post_init__(self):
+        self.year = str(self.year)
+        self.rangos = self.rangos or {}
+        self._monedas = self._mapa_monedas()
+        self._target_runs = self._mapa_target_runs()
+        self.result = self.calcular()
+
+    def _mapa_monedas(self):
+        if self.fondos_vigentes.empty or "RUN" not in self.fondos_vigentes.columns:
+            return {}
+
+        moneda_col = next(
+            (col for col in ["MONEDA", "MONEDA_SERIE", "MONEDA_CUOTA"] if col in self.fondos_vigentes.columns),
+            None
+        )
+        if moneda_col is None:
+            return {}
+
+        monedas = self.fondos_vigentes[["RUN", moneda_col]].dropna().copy()
+        monedas["RUN"] = monedas["RUN"].astype(str)
+        return monedas.drop_duplicates("RUN").set_index("RUN")[moneda_col].to_dict()
+
+    def _mapa_target_runs(self):
+        if self.target is None:
+            return None
+        if self.fondos_vigentes.empty:
+            return set()
+        if "RUN" not in self.fondos_vigentes.columns or "ADMINISTRADORA" not in self.fondos_vigentes.columns:
+            return set()
+
+        fondos = self.fondos_vigentes[
+            self.fondos_vigentes["ADMINISTRADORA"].astype(str).eq(str(self.target))
+        ].copy()
+        return set(fondos["RUN"].astype(str))
+
+    def _normalizar_data(self, df: pd.DataFrame):
+        df = df.copy()
+        if "FECHA" in df.columns:
+            df["FECHA"] = pd.to_datetime(df["FECHA"])
+            df = df.set_index("FECHA")
+        else:
+            df.index = pd.to_datetime(df.index)
+
+        df = df.sort_index()
+        decay_cols = [col for col in df.columns if self._es_columna_decay(col)]
+        ret_cols = [col for col in df.columns if col not in decay_cols]
+        returns = df[ret_cols].apply(pd.to_numeric, errors="coerce")
+        return returns, decay_cols
+
+    @staticmethod
+    def _es_columna_decay(col):
+        return str(col).upper().startswith("DECAY")
+
+    @staticmethod
+    def _parse_decay(col):
+        value = str(col).upper().replace("DECAY", "").replace("_", ".")
+        return float(value) / 100
+
+    @staticmethod
+    def _decay_label(decay):
+        pct = decay * 100
+        if float(pct).is_integer():
+            return int(pct)
+        return pct
+
+    @classmethod
+    def _decay_suffix(cls, decay):
+        return f"decay{cls._decay_label(decay)}"
+
+    @staticmethod
+    def _dato99(decay):
+        acumulado = 0.0
+        dato = 0
+        while acumulado < 0.999:
+            acumulado += (1 - decay) * (decay ** dato)
+            dato += 1
+        return dato
+
+    def _decays(self, decay_cols):
+        if self.decays is not None:
+            return [float(decay) for decay in self.decays]
+        return [self._parse_decay(col) for col in decay_cols]
+
+    def _runs_usd(self, returns: pd.DataFrame):
+        return [
+            run for run in returns.columns
+            if str(run).upper() != "USDCLP"
+            and (self._target_runs is None or str(run) in self._target_runs)
+            and str(self._monedas.get(str(run), "")).upper() == "USD"
+        ]
+
+    def _retornos_fondos(self, returns: pd.DataFrame):
+        cols = [
+            col for col in returns.columns
+            if str(col).upper() != "USDCLP"
+            and (self._target_runs is None or str(col) in self._target_runs)
+        ]
+        return returns[cols]
+
+    def _formato_resultado(self, values, retorno, metrica, decay, dato99, datos, incluir_valor_null=False):
+        year_mask = values.index.year.astype(str) == self.year
+        values = values.loc[year_mask]
+        datos = datos.loc[year_mask]
+        if incluir_valor_null:
+            stacked = values.reset_index()
+            stacked = stacked.rename(columns={stacked.columns[0]: "FECHA"})
+            stacked = stacked.melt(id_vars="FECHA", var_name="RUN", value_name="VALOR")
+        else:
+            stacked = values.stack().dropna().rename("VALOR").reset_index()
+        if stacked.empty:
+            return pd.DataFrame(columns=["FECHA", "RUN", "MONEDA", "METRICA", "DECAY", "DATO99", "RETORNO", "DATOS", "VALOR"])
+
+        stacked.columns = ["FECHA", "RUN", "VALOR"]
+        datos_stacked = datos.stack().rename("DATOS").reset_index()
+        datos_stacked.columns = ["FECHA", "RUN", "DATOS"]
+        stacked = stacked.merge(datos_stacked, on=["FECHA", "RUN"], how="left")
+        stacked = stacked[stacked["DATOS"] > 0].copy()
+        if stacked.empty:
+            return pd.DataFrame(columns=["FECHA", "RUN", "MONEDA", "METRICA", "DECAY", "DATO99", "RETORNO", "DATOS", "VALOR"])
+
+        stacked["RUN_KEY"] = stacked["RUN"].astype(str)
+        stacked["MONEDA"] = stacked["RUN_KEY"].map(self._monedas).fillna(self.moneda_default)
+        stacked["METRICA"] = metrica
+        stacked["DECAY"] = self._decay_label(decay) if decay is not None else pd.NA
+        stacked["DATO99"] = dato99 if dato99 is not None else pd.NA
+        stacked["RETORNO"] = retorno.upper()
+        stacked["DATOS"] = stacked["DATOS"].astype("Int64")
+        return stacked[["FECHA", "RUN", "MONEDA", "METRICA", "DECAY", "DATO99", "RETORNO", "DATOS", "VALOR"]]
+
+    @staticmethod
+    def _varianza_decay_acumulada(values: pd.DataFrame, decay: float):
+        arr = values.to_numpy(dtype=float, copy=True)
+        valid = ~np.isnan(arr)
+        squared = np.where(valid, arr * arr, 0.0)
+        out = np.empty_like(squared, dtype=float)
+        state = np.zeros(squared.shape[1], dtype=float)
+
+        for row in range(squared.shape[0]):
+            state *= decay
+            state += (1 - decay) * squared[row]
+            out[row] = state
+
+        out[valid.cumsum(axis=0) == 0] = np.nan
+        return pd.DataFrame(out, index=values.index, columns=values.columns)
+
+    @staticmethod
+    def _media_decay_acumulada(values: pd.DataFrame, decay: float):
+        arr = values.to_numpy(dtype=float, copy=True)
+        valid = ~np.isnan(arr)
+        arr = np.where(valid, arr, 0.0)
+        out = np.empty_like(arr, dtype=float)
+        state = np.zeros(arr.shape[1], dtype=float)
+
+        for row in range(arr.shape[0]):
+            state *= decay
+            state += (1 - decay) * arr[row]
+            out[row] = state
+
+        out[valid.cumsum(axis=0) == 0] = np.nan
+        return pd.DataFrame(out, index=values.index, columns=values.columns)
+
+    @staticmethod
+    def _covarianza_acumulada(values: pd.DataFrame, usd: pd.Series):
+        valid = values.notna() & usd.notna().to_numpy()[:, None]
+        x = values.where(valid, 0.0)
+        y = pd.DataFrame(
+            np.where(valid, usd.to_numpy()[:, None], 0.0),
+            index=values.index,
+            columns=values.columns
+        )
+
+        datos = valid.cumsum()
+        sum_x = x.cumsum()
+        sum_y = y.cumsum()
+        sum_xy = (x * y).cumsum()
+        cov = (sum_xy - (sum_x * sum_y / datos)) / (datos - 1)
+        cov = cov.mask(datos < 2)
+        return cov, datos
+
+    @staticmethod
+    def _covarianza_decay_acumulada(values: pd.DataFrame, usd: pd.Series, decay: float):
+        arr = values.to_numpy(dtype=float, copy=True)
+        usd_arr = usd.to_numpy(dtype=float, copy=True)[:, None]
+        valid = ~np.isnan(arr) & ~np.isnan(usd_arr)
+        product = np.where(valid, arr * usd_arr, 0.0)
+        out = np.empty_like(product, dtype=float)
+        state = np.zeros(product.shape[1], dtype=float)
+
+        for row in range(product.shape[0]):
+            state *= decay
+            state += (1 - decay) * product[row]
+            out[row] = state
+
+        datos = pd.DataFrame(valid, index=values.index, columns=values.columns).cumsum()
+        out[datos.to_numpy() == 0] = np.nan
+        cov = pd.DataFrame(out, index=values.index, columns=values.columns)
+        return cov, datos
+
+    def _varianza(self, returns, retorno):
+        datos = returns.notna().cumsum()
+        varianza = returns.expanding(min_periods=2).var(ddof=1)
+        return self._formato_resultado(
+            values=varianza,
+            retorno=retorno,
+            metrica="varianza",
+            decay=None,
+            dato99=None,
+            datos=datos
+        )
+
+    def _varianza_decay(self, returns, retorno, decay):
+        datos = returns.notna().cumsum()
+        dato99 = self._dato99(decay)
+        varianza = self._varianza_decay_acumulada(returns, decay)
+        varianza = varianza.mask(datos < dato99)
+        return self._formato_resultado(
+            values=varianza,
+            retorno=retorno,
+            metrica="varianza",
+            decay=decay,
+            dato99=dato99,
+            datos=datos,
+            incluir_valor_null=True
+        )
+
+    def _volatilidad(self, returns, retorno):
+        datos = returns.notna().cumsum()
+        sigma = returns.expanding(min_periods=2).std(ddof=1)
+        return self._formato_resultado(
+            values=sigma,
+            retorno=retorno,
+            metrica="sigma",
+            decay=None,
+            dato99=None,
+            datos=datos
+        )
+
+    def _volatilidad_decay(self, returns, retorno, decay):
+        datos = returns.notna().cumsum()
+        dato99 = self._dato99(decay)
+        varianza = self._varianza_decay_acumulada(returns, decay)
+        sigma = np.sqrt(varianza)
+        sigma = sigma.mask(datos < dato99)
+        return self._formato_resultado(
+            values=sigma,
+            retorno=retorno,
+            metrica="sigma",
+            decay=decay,
+            dato99=dato99,
+            datos=datos,
+            incluir_valor_null=True
+        )
+
+    def _metricas_var(self, sigma, media, retorno, decay, dato99, datos, incluir_valor_null, sufijo=None):
+        chunks = []
+        for confidence in [0.95, 0.99]:
+            confidence_label = int(confidence * 100)
+            z_score = norm.ppf(confidence)
+            for usar_media in [True, False]:
+                mu = media if usar_media else 0.0
+                values = z_score * sigma - mu
+                name_parts = [f"var{confidence_label}"]
+                if not usar_media:
+                    name_parts.append("mu0")
+                if decay is not None:
+                    name_parts.append(self._decay_suffix(decay))
+                if sufijo is not None:
+                    name_parts.append(sufijo)
+
+                chunk = self._formato_resultado(
+                    values=values,
+                    retorno=retorno,
+                    metrica="_".join(name_parts),
+                    decay=decay,
+                    dato99=dato99,
+                    datos=datos,
+                    incluir_valor_null=incluir_valor_null
+                )
+                if not chunk.empty:
+                    chunks.append(chunk)
+
+        if not chunks:
+            return pd.DataFrame()
+        return pd.concat(chunks, ignore_index=True)
+
+    def _value_at_risk(self, returns, retorno):
+        datos = returns.notna().cumsum()
+        sigma = returns.expanding(min_periods=2).std(ddof=1)
+        media = returns.expanding(min_periods=2).mean()
+        return self._metricas_var(
+            sigma=sigma,
+            media=media,
+            retorno=retorno,
+            decay=None,
+            dato99=None,
+            datos=datos,
+            incluir_valor_null=False
+        )
+
+    def _value_at_risk_decay(self, returns, retorno, decay):
+        datos = returns.notna().cumsum()
+        dato99 = self._dato99(decay)
+        varianza = self._varianza_decay_acumulada(returns, decay)
+        sigma = np.sqrt(varianza)
+        media = self._media_decay_acumulada(returns, decay)
+        sigma = sigma.mask(datos < dato99)
+        media = media.mask(datos < dato99)
+        return self._metricas_var(
+            sigma=sigma,
+            media=media,
+            retorno=retorno,
+            decay=decay,
+            dato99=dato99,
+            datos=datos,
+            incluir_valor_null=True
+        )
+
+    def _covarianza_usd(self, returns, retorno):
+        if "USDCLP" not in returns.columns:
+            return pd.DataFrame()
+
+        usd_runs = self._runs_usd(returns)
+        if not usd_runs:
+            return pd.DataFrame()
+
+        values, datos = self._covarianza_acumulada(returns[usd_runs], returns["USDCLP"])
+        return self._formato_resultado(
+            values=values,
+            retorno=retorno,
+            metrica="covarianza_usd",
+            decay=None,
+            dato99=None,
+            datos=datos
+        )
+
+    def _covarianza_usd_decay(self, returns, retorno, decay):
+        if "USDCLP" not in returns.columns:
+            return pd.DataFrame()
+
+        usd_runs = self._runs_usd(returns)
+        if not usd_runs:
+            return pd.DataFrame()
+
+        dato99 = self._dato99(decay)
+        values, datos = self._covarianza_decay_acumulada(returns[usd_runs], returns["USDCLP"], decay)
+        values = values.mask(datos < dato99)
+        return self._formato_resultado(
+            values=values,
+            retorno=retorno,
+            metrica="covarianza_usd",
+            decay=decay,
+            dato99=dato99,
+            datos=datos,
+            incluir_valor_null=True
+        )
+
+    @staticmethod
+    def _expandir_serie(serie: pd.Series, columnas: pd.Index):
+        return pd.DataFrame(
+            np.repeat(serie.to_numpy()[:, None], len(columnas), axis=1),
+            index=serie.index,
+            columns=columnas
+        )
+
+    def _metricas_clp(self, returns, retorno):
+        if "USDCLP" not in returns.columns:
+            return pd.DataFrame()
+
+        usd_runs = self._runs_usd(returns)
+        if not usd_runs:
+            return pd.DataFrame()
+
+        fund_returns = returns[usd_runs]
+        usd_return = returns["USDCLP"]
+        covarianza, datos = self._covarianza_acumulada(fund_returns, usd_return)
+        varianza_run = fund_returns.expanding(min_periods=2).var(ddof=1)
+        varianza_usd = self._expandir_serie(usd_return.expanding(min_periods=2).var(ddof=1), fund_returns.columns)
+        varianza_clp = varianza_run + varianza_usd + 2 * covarianza
+        sigma_clp = np.sqrt(varianza_clp)
+        media_run = fund_returns.expanding(min_periods=2).mean()
+        media_usd = self._expandir_serie(usd_return.expanding(min_periods=2).mean(), fund_returns.columns)
+        media_clp = (1 + media_run) * (1 + media_usd) - 1
+
+        chunks = []
+        for values, metrica in [
+            (varianza_clp, "varianza_clp"),
+            (sigma_clp, "sigma_clp"),
+        ]:
+            chunk = self._formato_resultado(
+                values=values,
+                retorno=retorno,
+                metrica=metrica,
+                decay=None,
+                dato99=None,
+                datos=datos
+            )
+            if not chunk.empty:
+                chunks.append(chunk)
+
+        chunk = self._metricas_var(
+            sigma=sigma_clp,
+            media=media_clp,
+            retorno=retorno,
+            decay=None,
+            dato99=None,
+            datos=datos,
+            incluir_valor_null=False,
+            sufijo="clp"
+        )
+        if not chunk.empty:
+            chunks.append(chunk)
+
+        if not chunks:
+            return pd.DataFrame()
+        return pd.concat(chunks, ignore_index=True)
+
+    def _metricas_clp_decay(self, returns, retorno, decay):
+        if "USDCLP" not in returns.columns:
+            return pd.DataFrame()
+
+        usd_runs = self._runs_usd(returns)
+        if not usd_runs:
+            return pd.DataFrame()
+
+        dato99 = self._dato99(decay)
+        fund_returns = returns[usd_runs]
+        usd_return = returns["USDCLP"]
+        covarianza, datos = self._covarianza_decay_acumulada(fund_returns, usd_return, decay)
+        varianza_run = self._varianza_decay_acumulada(fund_returns, decay)
+        varianza_usd = self._expandir_serie(
+            self._varianza_decay_acumulada(returns[["USDCLP"]], decay)["USDCLP"],
+            fund_returns.columns
+        )
+        varianza_clp = varianza_run + varianza_usd + 2 * covarianza
+        varianza_clp = varianza_clp.mask(datos < dato99)
+        sigma_clp = np.sqrt(varianza_clp)
+        media_run = self._media_decay_acumulada(fund_returns, decay)
+        media_usd = self._expandir_serie(
+            self._media_decay_acumulada(returns[["USDCLP"]], decay)["USDCLP"],
+            fund_returns.columns
+        )
+        media_clp = ((1 + media_run) * (1 + media_usd) - 1).mask(datos < dato99)
+
+        chunks = []
+        for values, metrica in [
+            (varianza_clp, "varianza_clp"),
+            (sigma_clp, "sigma_clp"),
+        ]:
+            chunk = self._formato_resultado(
+                values=values,
+                retorno=retorno,
+                metrica=metrica,
+                decay=decay,
+                dato99=dato99,
+                datos=datos,
+                incluir_valor_null=True
+            )
+            if not chunk.empty:
+                chunks.append(chunk)
+
+        chunk = self._metricas_var(
+            sigma=sigma_clp,
+            media=media_clp,
+            retorno=retorno,
+            decay=decay,
+            dato99=dato99,
+            datos=datos,
+            incluir_valor_null=True,
+            sufijo="clp"
+        )
+        if not chunk.empty:
+            chunks.append(chunk)
+
+        if not chunks:
+            return pd.DataFrame()
+        return pd.concat(chunks, ignore_index=True)
+
+    def calcular(self):
+        chunks = []
+        for retorno, df in self.data.items():
+            returns, decay_cols = self._normalizar_data(df)
+            fund_returns = self._retornos_fondos(returns)
+            retorno = str(retorno).upper()
+            if returns.empty or fund_returns.empty:
+                continue
+
+            for decay in self._decays(decay_cols):
+                for metric in [
+                    self._varianza_decay,
+                    self._volatilidad_decay,
+                    self._value_at_risk_decay,
+                ]:
+                    chunk = metric(fund_returns, retorno, decay)
+                    if not chunk.empty:
+                        chunks.append(chunk)
+
+                chunk = self._covarianza_usd_decay(returns, retorno, decay)
+                if not chunk.empty:
+                    chunks.append(chunk)
+
+                chunk = self._metricas_clp_decay(returns, retorno, decay)
+                if not chunk.empty:
+                    chunks.append(chunk)
+
+            for metric in [
+                self._varianza,
+                self._volatilidad,
+                self._value_at_risk,
+            ]:
+                chunk = metric(fund_returns, retorno)
+                if not chunk.empty:
+                    chunks.append(chunk)
+
+            chunk = self._covarianza_usd(returns, retorno)
+            if not chunk.empty:
+                chunks.append(chunk)
+
+            chunk = self._metricas_clp(returns, retorno)
+            if not chunk.empty:
+                chunks.append(chunk)
+
+        if not chunks:
+            return pd.DataFrame(columns=["FECHA", "RUN", "MONEDA", "METRICA", "DECAY", "DATO99", "RETORNO", "DATOS", "VALOR"])
+
+        result = pd.concat(chunks, ignore_index=True)
+        return result.sort_values(["FECHA", "RUN", "RETORNO", "METRICA", "DECAY"], na_position="last").reset_index(drop=True)
+
+
+@dataclass
+class MetricasExpost_Relativas:
+    year : str
+    data : Dict[str, pd.DataFrame] = field(default_factory=dict)
+    competidores : pd.DataFrame = field(default_factory=pd.DataFrame)
+    fondos_vigentes : pd.DataFrame = field(default_factory=pd.DataFrame)
+    target : Optional[str] = None
+    decays : Optional[List[float]] = None
+    moneda_default : str = "CLP"
+    result : pd.DataFrame = field(default_factory=pd.DataFrame)
+
+    def __post_init__(self):
+        self.year = str(self.year)
+        self._monedas = self._mapa_monedas()
+        self.result = self.calcular()
+
+    def _mapa_monedas(self):
+        if self.fondos_vigentes.empty or "RUN" not in self.fondos_vigentes.columns:
+            return {}
+
+        moneda_col = next(
+            (col for col in ["MONEDA", "MONEDA_SERIE", "MONEDA_CUOTA"] if col in self.fondos_vigentes.columns),
+            None
+        )
+        if moneda_col is None:
+            return {}
+
+        monedas = self.fondos_vigentes[["RUN", moneda_col]].dropna().copy()
+        monedas["RUN"] = monedas["RUN"].astype(str)
+        return monedas.drop_duplicates("RUN").set_index("RUN")[moneda_col].to_dict()
+
+    def _columna_target(self):
+        if self.competidores.empty:
+            return None
+        if "RUN_TARGET" in self.competidores.columns:
+            return "RUN_TARGET"
+        if self.target is not None and f"RUN_{self.target}" in self.competidores.columns:
+            return f"RUN_{self.target}"
+
+        run_cols = [col for col in self.competidores.columns if str(col).upper().startswith("RUN_")]
+        if run_cols:
+            return run_cols[0]
+        return None
+
+    def _columna_competidor(self):
+        for col in ["COMPETIDOR", "COMPETIDORES", "CPMETIDORES", "RUN_COMPETIDOR"]:
+            if col in self.competidores.columns:
+                return col
+        return None
+
+    def _grupos_competidores(self):
+        target_col = self._columna_target()
+        competitor_col = self._columna_competidor()
+        if target_col is None or competitor_col is None:
+            return {}
+
+        comp = self.competidores[[target_col, competitor_col]].dropna().copy()
+        comp[target_col] = comp[target_col].astype(str)
+        comp[competitor_col] = comp[competitor_col].astype(str)
+
+        grupos = {}
+        for run_target, group in comp.groupby(target_col):
+            competitors = group[competitor_col].drop_duplicates().tolist()
+            universo = [str(run_target)] + [run for run in competitors if run != str(run_target)]
+            grupos[str(run_target)] = universo
+        return grupos
+
+    @staticmethod
+    def _es_columna_decay(col):
+        return str(col).upper().startswith("DECAY")
+
+    @staticmethod
+    def _parse_decay(col):
+        value = str(col).upper().replace("DECAY", "").replace("_", ".")
+        return float(value) / 100
+
+    @staticmethod
+    def _decay_label(decay):
+        pct = decay * 100
+        if float(pct).is_integer():
+            return int(pct)
+        return pct
+
+    @staticmethod
+    def _dato99(decay):
+        acumulado = 0.0
+        dato = 0
+        while acumulado < 0.999:
+            acumulado += (1 - decay) * (decay ** dato)
+            dato += 1
+        return dato
+
+    def _decays(self, decay_cols):
+        if self.decays is not None:
+            return [float(decay) for decay in self.decays]
+        return [self._parse_decay(col) for col in decay_cols]
+
+    def _normalizar_data(self, df: pd.DataFrame):
+        df = df.copy()
+        if "FECHA" in df.columns:
+            df["FECHA"] = pd.to_datetime(df["FECHA"])
+            df = df.set_index("FECHA")
+        else:
+            df.index = pd.to_datetime(df.index)
+
+        df = df.sort_index()
+        decay_cols = [col for col in df.columns if self._es_columna_decay(col)]
+        ret_cols = [col for col in df.columns if col not in decay_cols]
+        returns = df[ret_cols].apply(pd.to_numeric, errors="coerce")
+        returns = returns[[col for col in returns.columns if str(col).upper() != "USDCLP"]]
+        returns.columns = returns.columns.astype(str)
+        return returns, decay_cols
+
+    @staticmethod
+    def _tracking_error_decay(active_return: pd.Series, decay: float):
+        values = active_return.to_numpy(dtype=float, copy=True)
+        valid = ~np.isnan(values)
+        squared = np.where(valid, values * values, 0.0)
+        out = np.empty(len(values), dtype=float)
+        state = 0.0
+
+        for i, value in enumerate(squared):
+            state *= decay
+            state += (1 - decay) * value
+            out[i] = state
+
+        out[np.cumsum(valid) == 0] = np.nan
+        return pd.Series(np.sqrt(out), index=active_return.index)
+
+    def _formato_tracking(self, values: pd.DataFrame, datos: pd.DataFrame, retorno, decay, dato99, incluir_valor_null):
+        year_mask = values.index.year.astype(str) == self.year
+        values = values.loc[year_mask]
+        datos = datos.loc[year_mask]
+
+        if incluir_valor_null:
+            stacked = values.reset_index()
+            stacked = stacked.rename(columns={stacked.columns[0]: "FECHA"})
+            stacked = stacked.melt(id_vars="FECHA", var_name="RUN_KEY", value_name="VALOR")
+        else:
+            stacked = values.stack().dropna().rename("VALOR").reset_index()
+            stacked.columns = ["FECHA", "RUN_KEY", "VALOR"]
+
+        if stacked.empty:
+            return self._empty_result()
+
+        datos_stacked = datos.stack().rename("DATOS").reset_index()
+        datos_stacked.columns = ["FECHA", "RUN_KEY", "DATOS"]
+        stacked = stacked.merge(datos_stacked, on=["FECHA", "RUN_KEY"], how="left")
+        stacked = stacked[stacked["DATOS"] > 0].copy()
+        if stacked.empty:
+            return self._empty_result()
+
+        keys = stacked["RUN_KEY"].str.split("|", n=1, expand=True)
+        stacked["RUN"] = keys[1]
+        stacked["MONEDA"] = stacked["RUN"].map(self._monedas).fillna(self.moneda_default)
+        stacked["METRICA"] = "tracking_error"
+        stacked["DECAY"] = self._decay_label(decay) if decay is not None else pd.NA
+        stacked["DATO99"] = dato99 if dato99 is not None else pd.NA
+        stacked["RETORNO"] = str(retorno).upper()
+        stacked["DATOS"] = stacked["DATOS"].astype("Int64")
+        return stacked[[
+            "FECHA", "RUN", "MONEDA", "METRICA", "DECAY",
+            "DATO99", "RETORNO", "DATOS", "VALOR"
+        ]]
+
+    @staticmethod
+    def _empty_result():
+        return pd.DataFrame(columns=[
+            "FECHA", "RUN", "MONEDA", "METRICA", "DECAY",
+            "DATO99", "RETORNO", "DATOS", "VALOR"
+        ])
+
+    def _tracking_grupos(self, returns: pd.DataFrame, grupos: Dict[str, List[str]], retorno):
+        values = {}
+        datos = {}
+        for run_target, universo in grupos.items():
+            disponibles = [run for run in universo if run in returns.columns]
+            if len(disponibles) < 2:
+                continue
+
+            group_returns = returns[disponibles]
+            for run in disponibles:
+                peers = [peer for peer in disponibles if peer != run]
+                benchmark = group_returns[peers].mean(axis=1, skipna=True)
+                active_return = group_returns[run] - benchmark
+                values[f"{run_target}|{run}"] = active_return.expanding(min_periods=2).std(ddof=1)
+                datos[f"{run_target}|{run}"] = group_returns[run].notna().cumsum()
+
+        if not values:
+            return self._empty_result()
+
+        values = pd.DataFrame(values, index=returns.index)
+        datos = pd.DataFrame(datos, index=returns.index)
+        return self._formato_tracking(
+            values=values,
+            datos=datos,
+            retorno=retorno,
+            decay=None,
+            dato99=None,
+            incluir_valor_null=False
+        )
+
+    def _tracking_grupos_decay(self, returns: pd.DataFrame, grupos: Dict[str, List[str]], retorno, decay):
+        dato99 = self._dato99(decay)
+        values = {}
+        datos = {}
+        for run_target, universo in grupos.items():
+            disponibles = [run for run in universo if run in returns.columns]
+            if len(disponibles) < 2:
+                continue
+
+            group_returns = returns[disponibles]
+            for run in disponibles:
+                peers = [peer for peer in disponibles if peer != run]
+                benchmark = group_returns[peers].mean(axis=1, skipna=True)
+                active_return = group_returns[run] - benchmark
+                count = group_returns[run].notna().cumsum()
+                te = self._tracking_error_decay(active_return, decay).mask(count < dato99)
+                values[f"{run_target}|{run}"] = te
+                datos[f"{run_target}|{run}"] = count
+
+        if not values:
+            return self._empty_result()
+
+        values = pd.DataFrame(values, index=returns.index)
+        datos = pd.DataFrame(datos, index=returns.index)
+        return self._formato_tracking(
+            values=values,
+            datos=datos,
+            retorno=retorno,
+            decay=decay,
+            dato99=dato99,
+            incluir_valor_null=True
+        )
+
+    def calcular(self):
+        grupos = self._grupos_competidores()
+        if not grupos:
+            return self._empty_result()
+
+        chunks = []
+        for retorno, df in self.data.items():
+            returns, decay_cols = self._normalizar_data(df)
+            if returns.empty:
+                continue
+
+            for decay in self._decays(decay_cols):
+                chunk = self._tracking_grupos_decay(returns, grupos, retorno, decay)
+                if not chunk.empty:
+                    chunks.append(chunk)
+
+            chunk = self._tracking_grupos(returns, grupos, retorno)
+            if not chunk.empty:
+                chunks.append(chunk)
+
+        if not chunks:
+            return self._empty_result()
+
+        result = pd.concat(chunks, ignore_index=True)
+        return result.sort_values(
+            ["FECHA", "RUN", "RETORNO", "METRICA", "DECAY"],
+            na_position="last"
+        ).reset_index(drop=True)
+
+

{lambda_risk-0.0.0.4 → lambda_risk-0.0.0.6}/lambda_risk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda_risk
-Version: 0.0.0.4
+Version: 0.0.0.6
 Description-Content-Type: text/markdown
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: requests>=2.32.3
@@ -10,6 +10,7 @@ Requires-Dist: PyQuantimClient
 Requires-Dist: holidays
 Requires-Dist: pyarrow
 Requires-Dist: fastparquet
+Requires-Dist: bcchapi
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: requires-dist

{lambda_risk-0.0.0.4 → lambda_risk-0.0.0.6}/lambda_risk.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 setup.py
 lambda_risk/__init__.py
 lambda_risk/client.py
+lambda_risk/risk.py
 lambda_risk.egg-info/PKG-INFO
 lambda_risk.egg-info/SOURCES.txt
 lambda_risk.egg-info/dependency_links.txt

{lambda_risk-0.0.0.4 → lambda_risk-0.0.0.6}/lambda_risk.egg-info/requires.txt

@@ -6,3 +6,4 @@ PyQuantimClient
 holidays
 pyarrow
 fastparquet
+bcchapi

{lambda_risk-0.0.0.4 → lambda_risk-0.0.0.6}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as f:
 
 setup(
     name='lambda_risk',
-    version='0.0.0.4',
+    version='0.0.0.6',
     packages=find_packages(),
     include_package_data=True,
     install_requires=[
@@ -17,7 +17,8 @@ setup(
         'PyQuantimClient',
         'holidays',
         'pyarrow',
-        'fastparquet'
+        'fastparquet',
+        'bcchapi'
         
     ],
     long_description=description,