lambda-risk 0.0.0.1__tar.gz

lambda_risk-0.0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: lambda-risk
+Version: 0.0.0.1
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: requests>=2.32.3
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: PyQuantimClient
+Requires-Dist: holidays
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+
+# Lambda SDK
+
+Sistema integral de gestión de riesgo financiero

lambda_risk-0.0.0.1/README.md

@@ -0,0 +1,3 @@
+# Lambda SDK
+
+Sistema integral de gestión de riesgo financiero

lambda_risk-0.0.0.1/lambda-risk/client.py

@@ -0,0 +1,396 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+import requests
+
+
+@dataclass
+class Config:
+    base_url: str
+    token: str
+    timeout: int = 120
+    poll_seconds: int = 3
+    max_polls: int = 120
+
+    def __post_init__(self) -> None:
+        self.base_url = self.base_url.rstrip("/")
+
+    @property
+    def headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+        }
+
+    def _format_elapsed(self, seconds: float) -> str:
+        if seconds < 60:
+            return f"{seconds:.2f}s"
+        minutes, remaining_seconds = divmod(seconds, 60)
+        return f"{int(minutes)}m {remaining_seconds:.2f}s"
+
+    def _print(self, message: str, log: bool = False) -> None:
+        if log:
+            print(f"[LOG] {message}")
+
+    def _get(self, endpoint: str, params: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        response = requests.get(
+            f"{self.base_url}/{endpoint.lstrip('/')}",
+            headers=self.headers,
+            params=params,
+            timeout=self.timeout,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _post(self, endpoint: str, payload: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        response = requests.post(
+            f"{self.base_url}/{endpoint.lstrip('/')}",
+            headers=self.headers,
+            json=payload or {},
+            timeout=self.timeout,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _start_export(self, endpoint_export: str, payload: dict[str, Any], log: bool = False) -> dict[str, Any]:
+        started_at = time.perf_counter()
+        export_data = self._post(endpoint_export, payload)
+        elapsed = self._format_elapsed(time.perf_counter() - started_at)
+        self._print(
+            f"API create_export={elapsed} | endpoint=/{endpoint_export.lstrip('/')} | module={export_data['module_name']} "
+            f"| export_id={export_data['export_id']} | job_id={export_data['job_id']}",
+            log,
+        )
+        return export_data
+
+    def get_health(self) -> dict[str, Any]:
+        response = requests.get(f"{self.base_url}/health", timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()
+
+    def get_export_status(
+        self,
+        module_name: str,
+        job_id: str,
+        export_id: str,
+        export_format: str = "parquet",
+    ) -> dict[str, Any]:
+        return self._get(
+            f"exports/{module_name}/{job_id}",
+            params={"export_id": export_id, "format": export_format},
+        )
+
+    def wait_until_done(
+        self,
+        module_name: str,
+        job_id: str,
+        export_id: str,
+        export_format: str = "parquet",
+        log: bool = False,
+    ) -> dict[str, Any]:
+        started_at = time.perf_counter()
+
+        for attempt in range(1, self.max_polls + 1):
+            status_data = self.get_export_status(module_name, job_id, export_id, export_format)
+            status = status_data["status"]
+            state = status_data["state"]
+            elapsed = self._format_elapsed(time.perf_counter() - started_at)
+
+            if status == "done":
+                self._print(
+                    f"API export_job={elapsed} | polls={attempt} | module={module_name} | state={state}",
+                    log,
+                )
+                return status_data
+            if status == "failed":
+                self._print(f"API export_job_failed={elapsed} | polls={attempt} | module={module_name}", log)
+                raise RuntimeError(
+                    f"Export failed. error_result={status_data.get('error_result')} "
+                    f"errors={status_data.get('errors')}"
+                )
+            time.sleep(self.poll_seconds)
+
+        raise TimeoutError("El export no termino dentro del tiempo maximo configurado.")
+
+    def _read_files(self, files: list[dict[str, Any]], log: bool = False):
+        import pandas as pd
+
+        if not files:
+            self._print("No hay archivos para descargar", log)
+            return pd.DataFrame()
+
+        dataframes: list[pd.DataFrame] = []
+        started_at = time.perf_counter()
+        total_files = len(files)
+        download_seconds = 0.0
+        read_seconds = 0.0
+        total_bytes = 0
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            for idx, file_info in enumerate(files, start=1):
+                file_name = file_info["file_name"]
+                local_path = os.path.join(tmpdir, f"{idx}_{file_name}")
+                file_started_at = time.perf_counter()
+
+                with requests.get(file_info["signed_url"], stream=True, timeout=600) as response:
+                    response.raise_for_status()
+                    with open(local_path, "wb") as file_obj:
+                        for chunk in response.iter_content(chunk_size=1024 * 1024):
+                            if chunk:
+                                file_obj.write(chunk)
+
+                download_seconds += time.perf_counter() - file_started_at
+                total_bytes += os.path.getsize(local_path)
+
+                read_started_at = time.perf_counter()
+                dataframes.append(pd.read_parquet(local_path))
+                read_seconds += time.perf_counter() - read_started_at
+
+        if not dataframes:
+            return pd.DataFrame()
+
+        concat_started_at = time.perf_counter()
+        dataframe = pd.concat(dataframes, ignore_index=True)
+        concat_elapsed = self._format_elapsed(time.perf_counter() - concat_started_at)
+        total_elapsed = self._format_elapsed(time.perf_counter() - started_at)
+        self._print(
+            f"DataFrame listo | rows={len(dataframe)} | cols={len(dataframe.columns)} "
+            f"| files={total_files} | mb={total_bytes / (1024 * 1024):.2f} "
+            f"| signed_url_download={self._format_elapsed(download_seconds)} "
+            f"| parquet_read={self._format_elapsed(read_seconds)} "
+            f"| concat={concat_elapsed} | client_download_read_total={total_elapsed}",
+            log,
+        )
+        return dataframe
+
+    def _export_dataframe(
+        self,
+        module_name: str,
+        endpoint_export: str,
+        payload: dict[str, Any],
+        log: bool = False,
+    ):
+        started_at = time.perf_counter()
+        export_data = self._start_export(endpoint_export, payload, log=log)
+
+        final_status = self.wait_until_done(
+            module_name=module_name,
+            job_id=export_data["job_id"],
+            export_id=export_data["export_id"],
+            export_format=export_data.get("format", "parquet"),
+            log=log,
+        )
+        dataframe = self._read_files(final_status.get("files", []), log)
+        total_elapsed = self._format_elapsed(time.perf_counter() - started_at)
+        self._print(f"Flujo completo finalizado en {total_elapsed}", log)
+        return dataframe
+
+
+class Datamart(Config):
+    def start_vc(
+        self,
+        fecha_inicio: str,
+        fecha_fin: str,
+        moneda: str,
+        categoria: Optional[str] = None,
+        agf: Optional[str] = None,
+        runs: Optional[list[str]] = None,
+        bruto: bool = True,
+        format: str = "parquet",
+        log: bool = False,
+    ) -> dict[str, Any]:
+        return self._start_export(
+            "exports/fm-valores-cuota",
+            {
+                "fecha_inicio": fecha_inicio,
+                "fecha_fin": fecha_fin,
+                "moneda": moneda,
+                "categoria": categoria,
+                "agf": agf,
+                "runs": runs or [],
+                "bruto": bruto,
+                "format": format,
+            },
+            log=log,
+        )
+
+    def export_vc(
+        self,
+        fecha_inicio: str,
+        fecha_fin: str,
+        moneda: str,
+        log: bool = False,
+        **params,
+    ):
+        payload = {"fecha_inicio": fecha_inicio, "fecha_fin": fecha_fin, "moneda": moneda, **params}
+        payload.setdefault("runs", [])
+        payload.setdefault("bruto", True)
+        payload["format"] = "parquet"
+        return self._export_dataframe("fm_valores_cuota", "exports/fm-valores-cuota", payload, log=log)
+
+    def start_fondos(self, ignorar_cambio_nombre: bool, log: bool = False, **params) -> dict[str, Any]:
+        payload = {"ignorar_cambio_nombre": ignorar_cambio_nombre, **params}
+        payload.setdefault("bruto", True)
+        return self._start_export("exports/fondos-mutuos", payload, log=log)
+
+    def export_fondos(self, ignorar_cambio_nombre: bool, log: bool = False, **params):
+        payload = {"ignorar_cambio_nombre": ignorar_cambio_nombre, **params}
+        payload.setdefault("bruto", True)
+        payload["format"] = "parquet"
+        return self._export_dataframe("fondos_mutuos", "exports/fondos-mutuos", payload, log=log)
+
+    def start_lva_aux(
+        self,
+        runs: Optional[list[str]] = None,
+        vigente: Optional[int] = None,
+        log: bool = False,
+    ) -> dict:
+        return self._start_export(
+            "exports/lva-aux-valores-cuota",
+            {"runs": runs or [], "vigente": vigente},
+            log=log,
+        )
+
+    def export_lva_aux(
+        self,
+        runs: Optional[list[str]] = None,
+        vigente: Optional[int] = None,
+        log: bool = False,
+    ):
+        return self._export_dataframe(
+            "lva_aux_valores_cuota",
+            "exports/lva-aux-valores-cuota",
+            {"runs": runs or [], "vigente": vigente, "format": "parquet"},
+            log=log,
+        )
+
+
+class FrameworkRiesgo(Config):
+    def start_benchmarks(self, categoria: str, year: str, log: bool = False) -> dict[str, Any]:
+        return self._start_export("exports/benchmarks", {"categoria": categoria, "year": year}, log=log)
+
+    def export_benchmarks(self, categoria: str, year: str, log: bool = False):
+        return self._export_dataframe(
+            "benchmarks",
+            "exports/benchmarks",
+            {"categoria": categoria, "year": year, "format": "parquet"},
+            log=log,
+        )
+
+    def start_metricas(self, start_date: str, end_date: str, log: bool = False, **payload) -> dict[str, Any]:
+        return self._start_export(
+            "exports/metricas-expost",
+            {"start_date": start_date, "end_date": end_date, **payload},
+            log=log,
+        )
+
+    def export_metricas(
+        self,
+        start_date: str,
+        end_date: str,
+        log: bool = False,
+        **payload,
+    ):
+        return self._export_dataframe(
+            "metricas_expost",
+            "exports/metricas-expost",
+            {"start_date": start_date, "end_date": end_date, **payload, "format": "parquet"},
+            log=log,
+        )
+
+    def start_alertas(self, start_date: str, end_date: str, log: bool = False, **payload) -> dict[str, Any]:
+        return self._start_export(
+            "exports/alertas-metricas-expost",
+            {"start_date": start_date, "end_date": end_date, **payload},
+            log=log,
+        )
+
+    def export_alertas(
+        self,
+        start_date: str,
+        end_date: str,
+        log: bool = False,
+        **payload,
+    ):
+        return self._export_dataframe(
+            "alertas_metricas_expost",
+            "exports/alertas-metricas-expost",
+            {"start_date": start_date, "end_date": end_date, **payload, "format": "parquet"},
+            log=log,
+        )
+
+    def start_niveles(self, fecha_inicio: str, fecha_fin: str, log: bool = False, **payload) -> dict[str, Any]:
+        return self._start_export(
+            "exports/niveles-riesgo",
+            {"fecha_inicio": fecha_inicio, "fecha_fin": fecha_fin, **payload},
+            log=log,
+        )
+
+    def export_niveles(
+        self,
+        fecha_inicio: str,
+        fecha_fin: str,
+        log: bool = False,
+        **payload,
+    ):
+        return self._export_dataframe(
+            "niveles_riesgo",
+            "exports/niveles-riesgo",
+            {"fecha_inicio": fecha_inicio, "fecha_fin": fecha_fin, **payload, "format": "parquet"},
+            log=log,
+        )
+
+    def start_srri(self, log: bool = False) -> dict[str, Any]:
+        return self._start_export("exports/srri", {}, log=log)
+
+    def export_srri(self, log: bool = False):
+        return self._export_dataframe("srri", "exports/srri", {"format": "parquet"}, log=log)
+
+
+class StorageFiles(Config):
+    def get_file_url(self, bucket: str, path: str, log: bool = False) -> dict[str, Any]:
+        started_at = time.perf_counter()
+        data = self._post("files/signed-url", {"bucket": bucket, "path": path})
+        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']}",
+            log,
+        )
+        return data
+
+    def download_file(
+        self,
+        bucket: str,
+        path: str,
+        destination: str | os.PathLike = ".",
+        log: bool = False,
+    ) -> Path:
+        file_info = self.get_file_url(bucket, path, log=log)
+        destination_path = Path(destination)
+        if destination_path.suffix:
+            output_path = destination_path
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+        else:
+            destination_path.mkdir(parents=True, exist_ok=True)
+            output_path = destination_path / file_info["file_name"]
+
+        started_at = time.perf_counter()
+        with requests.get(file_info["signed_url"], stream=True, timeout=600) as response:
+            response.raise_for_status()
+            with output_path.open("wb") as file_obj:
+                for chunk in response.iter_content(chunk_size=1024 * 1024):
+                    if chunk:
+                        file_obj.write(chunk)
+
+        elapsed = self._format_elapsed(time.perf_counter() - started_at)
+        self._print(
+            f"file_download={elapsed} | path={output_path} | mb={output_path.stat().st_size / (1024 * 1024):.2f}",
+            log,
+        )
+        return output_path

lambda_risk-0.0.0.1/lambda_risk.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: lambda-risk
+Version: 0.0.0.1
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: requests>=2.32.3
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: PyQuantimClient
+Requires-Dist: holidays
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+
+# Lambda SDK
+
+Sistema integral de gestión de riesgo financiero

lambda_risk-0.0.0.1/lambda_risk.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+lambda-risk/__init__.py
+lambda-risk/client.py
+lambda_risk.egg-info/PKG-INFO
+lambda_risk.egg-info/SOURCES.txt
+lambda_risk.egg-info/dependency_links.txt
+lambda_risk.egg-info/requires.txt
+lambda_risk.egg-info/top_level.txt

lambda_risk-0.0.0.1/lambda_risk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lambda_risk-0.0.0.1/lambda_risk.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pandas>=2.2.3
+requests>=2.32.3
+numpy
+scipy
+PyQuantimClient
+holidays

lambda_risk-0.0.0.1/lambda_risk.egg-info/top_level.txt

@@ -0,0 +1 @@
+lambda-risk

lambda_risk-0.0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lambda_risk-0.0.0.1/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r") as f:
+    description = f.read()
+    
+
+setup(
+    name='lambda-risk',
+    version='0.0.0.1',
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "pandas>=2.2.3",
+        "requests>=2.32.3",
+        'numpy',
+        'scipy',
+        'PyQuantimClient',
+        'holidays'
+        
+    ],
+    long_description=description,
+    long_description_content_type="text/markdown",
+            
+)