tesorotools-python 0.0.24__tar.gz → 0.0.25__tar.gz

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/.gitignore

@@ -21,4 +21,10 @@ dist/
 test/
 
 # font files
-*.otf
+*.otf
+
+# coverage
+.coverage
+
+# ruff
+.ruff_cache/

tesorotools_python-0.0.25/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: tesorotools-python
+Version: 0.0.25
+Requires-Python: >=3.13
+Requires-Dist: babel>=2.17
+Requires-Dist: eikon>=1.1
+Requires-Dist: lseg-data>=2.0
+Requires-Dist: matplotlib>=3.10
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pandas>=2.2
+Requires-Dist: psycopg[binary]>=3.1
+Requires-Dist: pyarrow>=18.0
+Requires-Dist: python-docx>=1.1
+Requires-Dist: pywin32>=311; sys_platform == 'win32'
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: bde
+Requires-Dist: requests>=2.31; extra == 'bde'

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/pyproject.toml

@@ -1,31 +1,34 @@
 [project]
 name = "tesorotools-python"
 requires-python = ">=3.13"
-version = "0.0.24"
+version = "0.0.25"
 dependencies = [
     # database and ORM
-    "psycopg[binary]",
+    "psycopg[binary]>=3.1",
     "SQLAlchemy>=2.0",
 
     # data analysis
-    "pandas",
-    "pyarrow",
-    "openpyxl",
+    "pandas>=2.2",
+    "pyarrow>=18.0",
+    "openpyxl>=3.1",
 
     # utils
-    "PyYAML",
-    "babel",
-    "eikon",
-    "lseg-data",
+    "PyYAML>=6.0",
+    "babel>=2.17",
+    "eikon>=1.1",
+    "lseg-data>=2.0",
 
     # data visualization
-    "matplotlib",
-    "python-docx",
+    "matplotlib>=3.10",
+    "python-docx>=1.1",
 
     # os dependencies
-    "pywin32>=311; sys_platform == 'win32'"
+    "pywin32>=311; sys_platform == 'win32'",
 ]
 
+[project.optional-dependencies]
+bde = ["requests>=2.31"]
+
 [dependency-groups]
 dev = [
     "ruff>=0.8",

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/src/tesorotools/__init__.py

@@ -1,6 +1,9 @@
 from tesorotools.artists.line_plot import Format, Legend, LinePlot
+from tesorotools.artists.stacked import StackedAreaPlot, StackedBarPlot
 from tesorotools.utils.config import TemplateLoader
 
 TemplateLoader.add_constructor("!line_plot", LinePlot.from_yaml)
 TemplateLoader.add_constructor("!format", Format.from_yaml)
 TemplateLoader.add_constructor("!legend", Legend.from_yaml)
+TemplateLoader.add_constructor("!stacked_area", StackedAreaPlot.from_yaml)
+TemplateLoader.add_constructor("!stacked_bar", StackedBarPlot.from_yaml)

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/src/tesorotools/artists/barh_plot.py

@@ -1,8 +1,5 @@
 from __future__ import annotations
 
-# Añadir anotaciones de tipos, el objetivo sería eliminar todos los diccionarios con anotaciones del tipo dict[str, Any] que dicen más bien poco
-# Tener cuidado para que nada de lo que está hecho con esta librería deje de funcionar
-
 from enum import Enum
 from pathlib import Path
 from typing import Any, Self

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/src/tesorotools/artists/line_plot.py

@@ -26,7 +26,7 @@ AX_CONFIG: dict[str, Any] = PLOT_CONFIG["ax"]
 FIG_CONFIG: dict[str, Any] = PLOT_CONFIG["figure"]
 
 
-def _style_spines(
+def style_spines(
     ax: Axes,
     decimals: int,
     units: str,
@@ -62,7 +62,7 @@ def _style_spines(
         tick.set_markeredgecolor(color)
 
 
-def _style_baseline(
+def style_baseline(
     ax: Axes,
     reference: float = 0,
     **baseline_config: Any,
@@ -106,8 +106,8 @@ def plot_line_chart(
         pass
 
     reference = 100 if base_100 else 0
-    _style_spines(ax, **format, **AX_CONFIG["spines"])
-    _style_baseline(ax, reference, **AX_CONFIG["baseline"])
+    style_spines(ax, **format, **AX_CONFIG["spines"])
+    style_baseline(ax, reference, **AX_CONFIG["baseline"])
     ax.legend(  # type: ignore[reportUnknownMemberType]
         loc="upper center",
         bbox_to_anchor=(0.5, LINE_PLOT_CONFIG["legend_sep"]),
@@ -179,8 +179,8 @@ class LinePlot:
     def __init__(
         self,
         out_path: Path,
-        data_path: Path,
-        series: dict[str, str],
+        data_path: Path | None = None,
+        series: dict[str, str] | None = None,
         scale: float = 1,
         start_date: datetime.datetime | None = None,
         end_date: datetime.datetime | None = None,
@@ -189,17 +189,28 @@ class LinePlot:
         baseline: bool = False,
         format: Format | None = None,
         legend: Legend | None = None,
+        data: pd.DataFrame | None = None,
     ) -> None:
 
         if out_path.suffix != ".png":
             raise ValueError(f"The out file {out_path} should be a .png file")
         self.out_path = out_path
 
-        if data_path.suffix != ".feather":
-            raise ValueError(
-                f"The data file {data_path} must be a .feather file"
-            )
-        self.data = pd.read_feather(data_path)
+        if data is not None and data_path is not None:
+            raise ValueError("Provide data or data_path, not both")
+        if data is not None:
+            self.data = data
+        elif data_path is not None:
+            if data_path.suffix != ".feather":
+                raise ValueError(
+                    f"The data file {data_path} must be a .feather file"
+                )
+            self.data = pd.read_feather(data_path)
+        else:
+            raise ValueError("Provide data or data_path")
+
+        if series is None:
+            raise ValueError("series is required")
 
         self.base_100 = base_100
         self.annotate = annotate  # unused for the moment
@@ -254,7 +265,7 @@ class LinePlot:
             pass
 
         assert self.format is not None
-        _style_spines(  # maybe make this function accept a Format object
+        style_spines(  # maybe make this function accept a Format object
             ax,
             decimals=self.format.decimals,
             units=self.format.units,
@@ -262,7 +273,7 @@ class LinePlot:
         )
         if self.baseline:
             reference = 100 if self.base_100 else 0
-            _style_baseline(ax, reference, **AX_CONFIG["baseline"])
+            style_baseline(ax, reference, **AX_CONFIG["baseline"])
 
         if self.legend is not None:
             ax.legend(  # type: ignore[reportUnknownMemberType]

tesorotools_python-0.0.25/src/tesorotools/artists/stacked.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Self
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from yaml.nodes import MappingNode
+
+from tesorotools.artists.line_plot import (
+    AX_CONFIG,
+    FIG_CONFIG,
+    Format,
+    Legend,
+    style_baseline,
+    style_spines,
+)
+from tesorotools.utils.config import TemplateLoader
+
+_DEFAULT_NCOL = 5
+_DEFAULT_SEP = -0.125
+
+
+class StackedAreaPlot:
+    """Stacked area chart with the tesorotools visual style.
+
+    Parameters match ``LinePlot`` where applicable so that
+    chart configs can switch between types by changing a
+    single field.
+    """
+
+    def __init__(
+        self,
+        out_path: Path,
+        data: pd.DataFrame,
+        series: dict[str, str],
+        *,
+        scale: float = 1,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        baseline: bool = False,
+        format: Format | None = None,
+        legend: Legend | None = None,
+    ) -> None:
+        if out_path.suffix != ".png":
+            raise ValueError(f"out_path must be .png: {out_path}")
+        self.out_path = out_path
+        self.data = data
+        self.series = series
+        self.scale = scale
+        self.start_date = start_date
+        self.end_date = end_date
+        self.baseline = baseline
+        self.format = format or Format()
+        self.legend = legend
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        cfg: dict[str, Any] = loader.construct_mapping(  # type: ignore[assignment]
+            node, deep=True
+        )
+        cfg.pop("id")
+        cfg["out_path"] = Path(cfg["out_path"])
+        cfg["data"] = pd.read_feather(cfg.pop("data_path"))
+        return cls(**cfg)
+
+    def plot(self) -> Axes:
+        start = (
+            pd.Timestamp(self.start_date)
+            if self.start_date
+            else self.data.index.min()
+        )
+        end = (
+            pd.Timestamp(self.end_date)
+            if self.end_date
+            else self.data.index.max()
+        )
+
+        plot_data = self.data.loc[start:end, list(self.series.keys())].dropna()
+        plot_data = plot_data * self.scale
+
+        fig: Figure = plt.figure(  # type: ignore[reportUnknownMemberType]
+            **FIG_CONFIG
+        )
+        ax: Axes = fig.add_subplot()
+
+        labels = list(self.series.values())
+        arrays: list[np.ndarray[tuple[int], np.dtype[np.float64]]] = [
+            plot_data[col].to_numpy(dtype=np.float64) for col in self.series
+        ]
+        ax.stackplot(  # type: ignore[reportUnknownMemberType]
+            plot_data.index,
+            *arrays,
+            labels=labels,
+            alpha=0.85,
+        )
+
+        style_spines(
+            ax,
+            decimals=self.format.decimals,
+            units=self.format.units,
+            **AX_CONFIG["spines"],
+        )
+        if self.baseline:
+            style_baseline(ax, 0, **AX_CONFIG["baseline"])
+
+        ncol = self.legend.ncol if self.legend else _DEFAULT_NCOL
+        sep = self.legend.sep if self.legend else _DEFAULT_SEP
+        ax.legend(  # type: ignore[reportUnknownMemberType]
+            loc="upper center",
+            bbox_to_anchor=(0.5, sep),
+            ncol=ncol,
+        )
+
+        fig.savefig(  # type: ignore[reportUnknownMemberType]
+            self.out_path
+        )
+        plt.close(fig)
+        return ax
+
+
+class StackedBarPlot:
+    """Stacked bar chart with the tesorotools visual style.
+
+    Positive and negative values are stacked separately so
+    that bars extend in both directions from the baseline.
+    """
+
+    def __init__(
+        self,
+        out_path: Path,
+        data: pd.DataFrame,
+        series: dict[str, str],
+        *,
+        scale: float = 1,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        baseline: bool = True,
+        format: Format | None = None,
+        legend: Legend | None = None,
+    ) -> None:
+        if out_path.suffix != ".png":
+            raise ValueError(f"out_path must be .png: {out_path}")
+        self.out_path = out_path
+        self.data = data
+        self.series = series
+        self.scale = scale
+        self.start_date = start_date
+        self.end_date = end_date
+        self.baseline = baseline
+        self.format = format or Format()
+        self.legend = legend
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        cfg: dict[str, Any] = loader.construct_mapping(  # type: ignore[assignment]
+            node, deep=True
+        )
+        cfg.pop("id")
+        cfg["out_path"] = Path(cfg["out_path"])
+        cfg["data"] = pd.read_feather(cfg.pop("data_path"))
+        return cls(**cfg)
+
+    def plot(self) -> Axes:
+        start = (
+            pd.Timestamp(self.start_date)
+            if self.start_date
+            else self.data.index.min()
+        )
+        end = (
+            pd.Timestamp(self.end_date)
+            if self.end_date
+            else self.data.index.max()
+        )
+
+        plot_data = self.data.loc[start:end, list(self.series.keys())].dropna()
+        plot_data = plot_data * self.scale
+
+        fig: Figure = plt.figure(  # type: ignore[reportUnknownMemberType]
+            figsize=(12, 6), **FIG_CONFIG
+        )
+        ax: Axes = fig.add_subplot()
+
+        cols = list(self.series.keys())
+        labels = list(self.series.values())
+
+        x = np.arange(len(plot_data))
+        bar_width = 0.7
+
+        pos_bottom: np.ndarray[tuple[int], np.dtype[np.float64]] = np.zeros(
+            len(plot_data)
+        )
+        neg_bottom: np.ndarray[tuple[int], np.dtype[np.float64]] = np.zeros(
+            len(plot_data)
+        )
+
+        for col, label in zip(cols, labels):
+            values: np.ndarray[tuple[int], np.dtype[np.float64]] = plot_data[
+                col
+            ].to_numpy(dtype=np.float64)
+            pos: np.ndarray[tuple[int], np.dtype[np.float64]] = np.where(
+                values >= 0, values, 0.0
+            )
+            neg: np.ndarray[tuple[int], np.dtype[np.float64]] = np.where(
+                values < 0, values, 0.0
+            )
+
+            color = (
+                ax.bar(  # type: ignore[reportUnknownMemberType]
+                    x,
+                    pos,
+                    bottom=pos_bottom,
+                    width=bar_width,
+                    label=label,
+                )
+                .patches[0]
+                .get_facecolor()
+            )
+            ax.bar(  # type: ignore[reportUnknownMemberType]
+                x,
+                neg,
+                bottom=neg_bottom,
+                width=bar_width,
+                color=color,
+            )
+            pos_bottom = pos_bottom + pos
+            neg_bottom = neg_bottom + neg
+
+        dates = plot_data.index
+        step = max(1, len(dates) // 12)
+        tick_pos = list(range(0, len(dates), step))
+        tick_labels = [dates[i].strftime("%Y") for i in tick_pos]
+        ax.set_xticks(  # type: ignore[reportUnknownMemberType]
+            tick_pos
+        )
+        ax.set_xticklabels(  # type: ignore[reportUnknownMemberType]
+            tick_labels
+        )
+
+        style_spines(
+            ax,
+            decimals=self.format.decimals,
+            units=self.format.units,
+            **AX_CONFIG["spines"],
+        )
+        if self.baseline:
+            style_baseline(ax, 0, **AX_CONFIG["baseline"])
+
+        ncol = self.legend.ncol if self.legend else _DEFAULT_NCOL
+        sep = self.legend.sep if self.legend else _DEFAULT_SEP
+        ax.legend(  # type: ignore[reportUnknownMemberType]
+            loc="upper center",
+            bbox_to_anchor=(0.5, sep),
+            ncol=ncol,
+        )
+
+        fig.savefig(  # type: ignore[reportUnknownMemberType]
+            self.out_path
+        )
+        plt.close(fig)
+        return ax

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/src/tesorotools/artists/type_curve.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-# pending to assure stylesheet data and fonts are only loaded once
-
 from pathlib import Path
 from typing import Any
 
@@ -9,9 +7,12 @@ import matplotlib.pyplot as plt
 import pandas as pd
 from matplotlib.axes import Axes
 from matplotlib.figure import Figure
-from matplotlib.ticker import FuncFormatter
 from pandas import Timestamp
 
+from tesorotools.artists.line_plot import (
+    style_baseline,
+    style_spines,
+)
 from tesorotools.utils.config import merge
 from tesorotools.utils.matplotlib import (
     PLOT_CONFIG,
@@ -26,54 +27,13 @@ FIG_CONFIG: dict[str, Any] = PLOT_CONFIG["figure"]
 load_fonts()
 
 
-def _style_spines(
-    ax: Axes,
-    decimals: int,
-    units: str,
-    *,
-    color: str,
-    linewidth: float,
-) -> None:
-    ax.grid(  # type: ignore[reportUnknownMemberType]
-        visible=True, axis="y"
-    )
-    for spine in ax.spines.values():
-        spine.set_color(color)
-        spine.set_linewidth(linewidth)
-    ax.yaxis.tick_right()
-
-    def _fmt_tick(y: float, _pos: int) -> str:
-        return format_annotation(y, decimals, units)
-
-    ax.yaxis.set_major_formatter(FuncFormatter(_fmt_tick))
-    ax.tick_params(  # type: ignore[reportUnknownMemberType]
-        axis="both", which="major"
-    )
+def _rotate_xticks(ax: Axes) -> None:
     ax.set_xticks(  # type: ignore[reportUnknownMemberType]
         ax.get_xticks(),
         ax.get_xticklabels(),  # type: ignore[reportArgumentType]
         rotation=45,
         ha="right",
     )
-    for tick in ax.get_xticklines():
-        tick.set_markeredgecolor(color)
-    for tick in ax.get_yticklines():
-        tick.set_markeredgecolor(color)
-
-
-def _style_baseline(ax: Axes, **baseline_config: Any) -> None:
-    color: str = baseline_config["color"]
-    bottom_lim, top_lim = ax.get_ylim()
-    ax.set_ylim(bottom=min(0, bottom_lim), top=max(0, top_lim))
-    bottom_lim, top_lim = ax.get_ylim()
-    if bottom_lim == 0:
-        ax.spines["bottom"].set_edgecolor(color)
-    elif top_lim == 0:
-        ax.spines["top"].set_edgecolor(color)
-    else:
-        ax.axhline(  # type: ignore[reportUnknownMemberType]
-            y=0, **baseline_config
-        )
 
 
 def _format_data(data: pd.DataFrame) -> dict[str, Any]:
@@ -204,8 +164,9 @@ def plot_type_curve(
         formatted_assets["current_date"],
         **merged_config["line"],
     )
-    _style_spines(ax, **merged_config["yaxis"], **AX_CONFIG["spines"])
-    _style_baseline(ax, **AX_CONFIG["baseline"])
+    style_spines(ax, **merged_config["yaxis"], **AX_CONFIG["spines"])
+    _rotate_xticks(ax)
+    style_baseline(ax, 0, **AX_CONFIG["baseline"])
     ax.legend(  # type: ignore[reportUnknownMemberType]
         loc="upper center",
         bbox_to_anchor=(0.5, merged_config["legend_sep"]),

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/src/tesorotools/convert.py

@@ -90,7 +90,7 @@ if __name__ == "__main__":
         ]
         independent_trimmed_df: pd.DataFrame = trim(independent_full_df)  # type: ignore[assignment]
         dependent_trimmed_df: pd.DataFrame = compute_derivate_series(
-            resolved_dict["dependent"],  # type: ignore[arg-type]
+            resolved_dict["rules"],  # type: ignore[arg-type]
             independent_trimmed_df,
         )
         offsets_config: Any = read_config(Path("examples") / "offsets.yaml")

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/src/tesorotools/data_sources/lseg.py

@@ -1,9 +1,14 @@
+import logging
 import time
 from pathlib import Path
 
 import lseg.data as ld
 import pandas as pd
 
+logger = logging.getLogger(__name__)
+
+MAX_RETRIES = 150
+
 
 def get_series(
     api_key: str,
@@ -16,7 +21,7 @@ def get_series(
     datapoint_limit: int = 2_000,
     cache_path: Path | None = None,
 ) -> pd.DataFrame:
-    """Downloads data from LSEG given that you have a valid API key"""
+    """Downloads data from LSEG given a valid API key."""
     ld.open_session(app_key=api_key)
     fields = ["TIMESTAMP", "CLOSE"] if fields is None else fields
 
@@ -53,7 +58,10 @@ def get_series(
             if cache_file_path is None:
                 partial_data.append(data)
             if downloaded_dates + download_step < len(dates_list):
-                print(f"Waiting {cooldown} seconds for LSEG to cool down...")
+                logger.info(
+                    "Waiting %d seconds for LSEG cooldown...",
+                    cooldown,
+                )
                 time.sleep(cooldown)
         downloaded_dates += download_step
     return data
@@ -67,10 +75,11 @@ def block_download(
     fields: list[str] | None = None,
     cooldown: int = 60,
     file_path: Path | None = None,
+    max_retries: int = MAX_RETRIES,
 ) -> pd.DataFrame:
     interval = "daily" if freq == "B" else freq
 
-    while True:
+    for attempt in range(1, max_retries + 1):
         try:
             data: pd.DataFrame | None = ld.get_history(  # type: ignore[reportUnknownMemberType]
                 universe=series_id_list,
@@ -92,11 +101,22 @@ def block_download(
                 data.to_csv(file_path)
             return data
         except ld.errors.LDError as e:
-            print(f"LSEG error: {e}")
-            print("This is probably not our fault")
-        print(f"Waiting {cooldown} seconds for LSEG to cool down...")
+            logger.warning(
+                "LSEG error (attempt %d/%d): %s",
+                attempt,
+                max_retries,
+                e,
+            )
+            if attempt == max_retries:
+                raise
+        logger.info(
+            "Waiting %d seconds for LSEG cooldown...",
+            cooldown,
+        )
         time.sleep(cooldown)
 
+    raise RuntimeError("Unreachable")
+
 
 def concat_partial_data(
     cache_path: Path | None,

{tesorotools_python-0.0.24 → tesorotools_python-0.0.25}/src/tesorotools/database/push.py

@@ -44,14 +44,9 @@ def flash_to_database_format(data: pd.DataFrame) -> pd.DataFrame:
         columns=["offset", "difference_type", "stat"]
     )
     database_data["value_meta"] = pd.NA
-    print(database_data)
     return database_data
 
 
-def database_to_flash_format() -> None:
-    pass
-
-
 def push_to_database(data: pd.DataFrame, conn_string: str, table: str) -> None:
     engine: Any = create_engine(url=conn_string)
     data.to_sql(
@@ -61,9 +56,3 @@ def push_to_database(data: pd.DataFrame, conn_string: str, table: str) -> None:
         chunksize=1000,
         index=False,
     )
-
-
-def pull_from_database(
-    conn_string: str, start: str, end: str, series: list[str]
-) -> None:
-    _ = conn_string, start, end, series