tesorotools-python 0.0.27__tar.gz → 0.0.29__tar.gz

{tesorotools_python-0.0.27 → tesorotools_python-0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tesorotools-python
-Version: 0.0.27
+Version: 0.0.29
 Requires-Python: >=3.13
 Requires-Dist: babel>=2.17
 Requires-Dist: eikon>=1.1

{tesorotools_python-0.0.27 → tesorotools_python-0.0.29}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "tesorotools-python"
 requires-python = ">=3.13"
-version = "0.0.27"
+version = "0.0.29"
 dependencies = [
     # database and ORM
     "psycopg[binary]>=3.1",

{tesorotools_python-0.0.27 → tesorotools_python-0.0.29}/src/tesorotools/artists/line_plot.py

@@ -96,6 +96,100 @@ def auto_ncol(ax: Axes, labels: list[str]) -> int:
     return min(ncol, len(labels))
 
 
+def annotate_last_values(
+    ax: Axes,
+    plot_data: pd.DataFrame,
+    *,
+    decimals: int,
+    units: str,
+    series_styles: dict[str, dict[str, Any]] | None = None,
+    annotate_color: str | None = None,
+) -> None:
+    """Label the last non-NaN value of each column on the right.
+
+    Colour priority (highest first): ``annotate_color``
+    (global override), ``series_styles[col]['color']``,
+    the Matplotlib line colour.
+
+    Labels are packed vertically in display space so that
+    series ending at nearly the same value do not overlap.
+    The x-axis limit is extended by the widest label so
+    the text is not clipped by the axes frame.
+    """
+    fig = ax.get_figure()
+    if fig is None:
+        return
+    styles = series_styles or {}
+
+    lines_by_label = {str(line.get_label()): line for line in ax.lines}
+    entries: list[tuple[Any, float, str, Any]] = []
+    for col in plot_data.columns:
+        col_series: pd.Series[float] = plot_data[col].dropna()
+        if col_series.empty:
+            continue
+        last_date = col_series.index[-1]
+        last_val = float(col_series.iloc[-1])
+        if annotate_color is not None:
+            color: Any = annotate_color
+        else:
+            override = styles.get(col, {}).get("color")
+            if override is not None:
+                color = override
+            else:
+                line = lines_by_label.get(col)
+                color = line.get_color() if line is not None else "black"
+        entries.append((last_date, last_val, col, color))
+
+    if not entries:
+        return
+
+    fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+    renderer = fig.canvas.get_renderer()  # type: ignore[reportUnknownMemberType]
+    trans = ax.transData
+
+    sample = ax.text(  # type: ignore[reportUnknownMemberType]
+        0, 0, "0"
+    )
+    text_height = (
+        sample.get_window_extent(renderer).height  # type: ignore[reportUnknownArgumentType]
+        * 1.15
+    )
+    sample.remove()
+
+    entries.sort(key=lambda e: e[1])
+    placements: list[float] = []
+    prev_y = -float("inf")
+    for _, val, _, _ in entries:
+        y_display: float = trans.transform((0, val))[1]  # type: ignore[reportUnknownArgumentType]
+        if y_display - prev_y < text_height:
+            y_display = prev_y + text_height
+        placements.append(y_display)
+        prev_y = y_display
+
+    max_label_width = 0.0
+    for (date, val, _, color), packed_y in zip(entries, placements):
+        orig_y: float = trans.transform((0, val))[1]  # type: ignore[reportUnknownArgumentType]
+        dy_pts = (packed_y - orig_y) * 72.0 / fig.dpi
+        text = format_annotation(val, decimals, units)
+        t = ax.annotate(  # type: ignore[reportUnknownMemberType]
+            text,
+            xy=(date, val),
+            xytext=(5, dy_pts),
+            textcoords="offset points",
+            color=color,
+            va="center",
+            ha="left",
+        )
+        width = t.get_window_extent(renderer).width  # type: ignore[reportUnknownArgumentType]
+        max_label_width = max(max_label_width, width)
+
+    inv = trans.inverted()
+    x0: float = inv.transform((0, 0))[0]  # type: ignore[reportUnknownArgumentType]
+    x1: float = inv.transform((max_label_width + 10, 0))[0]  # type: ignore[reportUnknownArgumentType]
+    xmin, xmax = ax.get_xlim()
+    ax.set_xlim(xmin, xmax + (x1 - x0))
+
+
 def style_spines(
     ax: Axes,
     decimals: int,
@@ -290,6 +384,7 @@ class LinePlot:
         end_date: datetime.datetime | None = None,
         base_100: bool = False,
         annotate: bool = False,
+        annotate_color: str | None = None,
         baseline: bool = False,
         format: Format | None = None,
         legend: Legend | None = None,
@@ -320,7 +415,8 @@ class LinePlot:
             raise ValueError("series is required")
 
         self.base_100 = base_100
-        self.annotate = annotate  # unused for the moment
+        self.annotate = annotate
+        self.annotate_color = annotate_color
         self.format = format
         self.start_date = start_date
         self.end_date = end_date
@@ -379,10 +475,17 @@ class LinePlot:
         else:
             plot_data.plot(ax=ax)
 
-        if self.annotate:  # not implemented yet
-            pass
-
         assert self.format is not None
+        if self.annotate:
+            annotate_last_values(
+                ax,
+                plot_data,
+                decimals=self.format.decimals,
+                units=self.format.units,
+                series_styles=self.series_styles,
+                annotate_color=self.annotate_color,
+            )
+
         style_spines(  # maybe make this function accept a Format object
             ax,
             decimals=self.format.decimals,

{tesorotools_python-0.0.27 → tesorotools_python-0.0.29}/src/tesorotools/pipeline/engine.py

@@ -51,6 +51,12 @@ def apply_transformations(
 ) -> pd.DataFrame:
     """Apply rules sequentially to a DataFrame.
 
+    New columns are accumulated in a dict and merged into
+    *result* only when a later rule reads from them (or at
+    the end).  This avoids per-rule fragmentation of the
+    DataFrame and pandas' ``PerformanceWarning`` when many
+    rules (100+) are applied.
+
     Parameters
     ----------
     df
@@ -64,8 +70,10 @@ def apply_transformations(
         Copy of *df* with new columns added by the rules.
     """
     result = df.copy()
+    pending: dict[str, pd.Series[float]] = {}
     for rule in rules:
-        missing = [d for d in rule.dependencies if d not in result.columns]
+        available = set(result.columns) | set(pending)
+        missing = [d for d in rule.dependencies if d not in available]
         if missing:
             logger.warning(
                 "Skipping %s: missing dependencies %s",
@@ -73,5 +81,21 @@ def apply_transformations(
                 missing,
             )
             continue
-        result[rule.output_name] = rule.compute(result)
+        # rule.compute() reads from result; flush pending
+        # into result if this rule needs any pending column.
+        if any(d in pending for d in rule.dependencies):
+            result = pd.concat(
+                [
+                    result,
+                    pd.DataFrame(pending, index=result.index),
+                ],
+                axis=1,
+            )
+            pending = {}
+        pending[rule.output_name] = rule.compute(result)
+    if pending:
+        result = pd.concat(
+            [result, pd.DataFrame(pending, index=result.index)],
+            axis=1,
+        )
     return result