tesorotools-python 0.0.35__tar.gz → 0.0.36__tar.gz

{tesorotools_python-0.0.35 → tesorotools_python-0.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tesorotools-python
-Version: 0.0.35
+Version: 0.0.36
 Requires-Python: >=3.13
 Requires-Dist: babel>=2.17
 Requires-Dist: matplotlib>=3.10

{tesorotools_python-0.0.35 → tesorotools_python-0.0.36}/pyproject.toml

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

tesorotools_python-0.0.36/src/tesorotools/__init__.py

@@ -0,0 +1,115 @@
+"""tesorotools public API.
+
+Importing ``tesorotools`` eagerly loads artist and render
+classes (their modules run matplotlib/locale setup as side
+effects) and registers their YAML tags via
+``_register_builtins``.
+
+Provider subclasses gated by optional extras
+(``BdeProvider`` requires ``[bde]``, ``EcbProvider``
+requires ``[ecb]``) are exposed lazily through
+``__getattr__``; importing this module does not require the
+extras to be installed.
+
+Third parties extend the package via ``register_artist``,
+``register_tag``, and ``register_provider``.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from tesorotools.providers.bde import BdeProvider
+    from tesorotools.providers.ecb import EcbProvider
+
+from tesorotools._registry import (
+    Artist,
+    get_artist,
+    get_provider,
+    register_artist,
+    register_provider,
+    register_tag,
+)
+from tesorotools.artists import (
+    Format,
+    HorizontalBarChart,
+    Legend,
+    LinePlot,
+    StackedAreaPlot,
+    StackedBarPlot,
+    TypeCurve,
+)
+from tesorotools.providers.base import DataProvider
+from tesorotools.render import (
+    Content,
+    Image,
+    Images,
+    Report,
+    Section,
+    Subtitle,
+    Table,
+    Text,
+    Title,
+)
+
+
+def _register_builtins() -> None:
+    register_artist("line_plot", LinePlot)
+    register_artist("stacked_area", StackedAreaPlot)
+    register_artist("stacked_bar", StackedBarPlot)
+    register_artist("barh", HorizontalBarChart)
+    register_artist("type_curve", TypeCurve)
+
+    register_tag("format", Format)
+    register_tag("legend", Legend)
+    register_tag("report", Report)
+    register_tag("section", Section)
+    register_tag("image", Image)
+    register_tag("images", Images)
+    register_tag("table", Table)
+    register_tag("text", Text)
+    register_tag("title", Title)
+    register_tag("subtitle", Subtitle)
+
+
+_register_builtins()
+
+
+__all__ = [
+    "Artist",
+    "BdeProvider",
+    "Content",
+    "DataProvider",
+    "EcbProvider",
+    "Format",
+    "HorizontalBarChart",
+    "Image",
+    "Images",
+    "Legend",
+    "LinePlot",
+    "Report",
+    "Section",
+    "StackedAreaPlot",
+    "StackedBarPlot",
+    "Subtitle",
+    "Table",
+    "Text",
+    "Title",
+    "TypeCurve",
+    "get_artist",
+    "get_provider",
+    "register_artist",
+    "register_provider",
+    "register_tag",
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "BdeProvider":
+        from tesorotools.providers.bde import BdeProvider
+
+        return BdeProvider
+    if name == "EcbProvider":
+        from tesorotools.providers.ecb import EcbProvider
+
+        return EcbProvider
+    raise AttributeError(f"module 'tesorotools' has no attribute {name!r}")

tesorotools_python-0.0.36/src/tesorotools/_registry.py

@@ -0,0 +1,117 @@
+"""Registries for artists, providers, and YAML tags.
+
+Single source of truth for "name -> class" lookups used both
+by the YAML loader (``TemplateLoader``) and by code that
+dispatches by string name.
+
+Three public entry points:
+
+``register_artist(name, cls)``
+    Adds ``cls`` to the artist registry **and** registers the
+    YAML tag ``!{name}`` via ``cls.from_yaml``.  Use for
+    chart/figure classes (LinePlot, StackedAreaPlot, etc.).
+
+``register_tag(name, constructor)``
+    Registers a YAML tag ``!{name}`` only.  Use for things
+    that exist as YAML constructors but are not artists or
+    providers (Format, Legend, Title, Subtitle, Section,
+    Image, Text, Table, Report).
+
+``register_provider(name, cls)``
+    Adds ``cls`` to the provider registry.  Programmatic
+    only -- providers do not appear in YAML today.
+
+Look up registered classes via ``get_artist`` / ``get_provider``;
+both raise ``KeyError`` listing the available names.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Protocol, cast
+
+from yaml.nodes import MappingNode
+
+from tesorotools.providers.base import DataProvider
+from tesorotools.utils.template import TemplateLoader
+
+
+class Artist(Protocol):
+    """Anything constructible from a YAML mapping node.
+
+    Concrete artists satisfy this Protocol structurally;
+    inheriting from it is not required.
+
+    The ``loader`` parameter is typed as ``Any`` because some
+    in-tree ``from_yaml`` classmethods are declared with
+    ``yaml.Loader`` (the base class) and others with
+    ``TemplateLoader``; both work at runtime since the loader
+    is always a ``TemplateLoader``.
+    """
+
+    @classmethod
+    def from_yaml(cls, loader: Any, node: MappingNode) -> Any: ...
+
+
+YamlConstructor = Callable[[Any, MappingNode], Any]
+
+
+_ARTIST_REGISTRY: dict[str, type[Artist]] = {}
+_PROVIDER_REGISTRY: dict[str, type[DataProvider]] = {}
+
+
+def register_artist(name: str, cls: type[Artist]) -> None:
+    """Register ``cls`` as the artist for ``name``.
+
+    Adds ``cls`` to the artist registry and binds the YAML
+    tag ``!{name}`` to ``cls.from_yaml``.  Re-registering the
+    same name overrides both bindings.
+    """
+    _ARTIST_REGISTRY[name] = cls
+    TemplateLoader.add_constructor(
+        f"!{name}", cast(YamlConstructor, cls.from_yaml)
+    )
+
+
+def get_artist(name: str) -> type[Artist]:
+    try:
+        return _ARTIST_REGISTRY[name]
+    except KeyError:
+        available = sorted(_ARTIST_REGISTRY)
+        raise KeyError(
+            f"No artist registered as {name!r}. Available: {available}"
+        ) from None
+
+
+def register_provider(name: str, cls: type[DataProvider]) -> None:
+    """Register ``cls`` as the provider for ``name``."""
+    _PROVIDER_REGISTRY[name] = cls
+
+
+def get_provider(name: str) -> type[DataProvider]:
+    try:
+        return _PROVIDER_REGISTRY[name]
+    except KeyError:
+        available = sorted(_PROVIDER_REGISTRY)
+        raise KeyError(
+            f"No provider registered as {name!r}. Available: {available}"
+        ) from None
+
+
+def register_tag(
+    name: str,
+    constructor: type[Artist] | YamlConstructor,
+) -> None:
+    """Register a YAML tag ``!{name}``.
+
+    Accepts either a class with a ``from_yaml`` classmethod
+    or a bare callable matching the loader signature.  Use
+    ``register_artist`` / ``register_provider`` instead when
+    the registered name should also be looked up by code.
+    """
+    if isinstance(constructor, type):
+        cls = cast(type[Artist], constructor)
+        TemplateLoader.add_constructor(
+            f"!{name}", cast(YamlConstructor, cls.from_yaml)
+        )
+    else:
+        TemplateLoader.add_constructor(f"!{name}", constructor)

tesorotools_python-0.0.36/src/tesorotools/artists/__init__.py

@@ -0,0 +1,25 @@
+"""Public artist API.
+
+Importing this module applies the matplotlib stylesheet
+defined by ``tesorotools.utils.globals.STYLE_SHEET``.
+"""
+
+import matplotlib.style
+
+from tesorotools.artists.barh_plot import HorizontalBarChart
+from tesorotools.artists.line_plot import Format, Legend, LinePlot
+from tesorotools.artists.stacked import StackedAreaPlot, StackedBarPlot
+from tesorotools.artists.type_curve import TypeCurve
+from tesorotools.utils.globals import STYLE_SHEET
+
+matplotlib.style.use(STYLE_SHEET)
+
+__all__ = [
+    "Format",
+    "HorizontalBarChart",
+    "Legend",
+    "LinePlot",
+    "StackedAreaPlot",
+    "StackedBarPlot",
+    "TypeCurve",
+]

tesorotools_python-0.0.36/src/tesorotools/artists/type_curve.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Self
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from pandas import Timestamp
+from yaml.nodes import MappingNode
+
+from tesorotools.artists.line_plot import (
+    AX_CONFIG,
+    FIG_CONFIG,
+    Format,
+    Legend,
+    style_baseline,
+    style_spines,
+)
+from tesorotools.utils.matplotlib import (
+    PLOT_CONFIG,
+    format_annotation,
+    load_fonts,
+)
+from tesorotools.utils.template import TemplateLoader
+
+TYPE_CURVE_CONFIG: dict[str, Any] = PLOT_CONFIG["type_curve"]
+
+load_fonts()
+
+
+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",
+    )
+
+
+def _format_data(data: pd.DataFrame) -> dict[str, Any]:
+    """Reduce raw daily data to the five series the chart draws.
+
+    Returns max/min envelopes for the current and previous
+    years plus the snapshot of the most recent observation.
+    """
+    date_index: pd.DatetimeIndex = data.index  # type: ignore[assignment]
+    current_date: Timestamp = date_index.max()  # type: ignore[assignment]
+    current_year: int = current_date.year
+    last_year: int = (current_date - pd.DateOffset(years=1)).year
+
+    current_data: pd.Series[Any] = data.loc[current_date, :]  # type: ignore[assignment]
+    current_data.name = "current_data"
+
+    current_year_data: pd.DataFrame = data.loc[
+        date_index.year == current_year, :
+    ]
+    current_year_max: pd.Series[Any] = current_year_data.max()
+    current_year_max.name = "current_year_max"
+    current_year_min: pd.Series[Any] = current_year_data.min()
+    current_year_min.name = "current_year_min"
+
+    last_year_data: pd.DataFrame = data.loc[date_index.year == last_year, :]
+    last_year_max: pd.Series[Any] = last_year_data.max()
+    last_year_max.name = "last_year_max"
+    last_year_min: pd.Series[Any] = last_year_data.min()
+    last_year_min.name = "last_year_min"
+
+    formatted_data: pd.DataFrame = pd.concat(
+        [
+            last_year_max,
+            last_year_min,
+            current_year_max,
+            current_year_min,
+            current_data,
+        ],
+        axis=1,
+    )
+
+    return {
+        "data": formatted_data,
+        "current_date": current_date.strftime("%d/%m/%Y"),
+        "current_year": current_year,
+        "last_year": last_year,
+    }
+
+
+class TypeCurve:
+    """Type-curve chart with the tesorotools visual style.
+
+    Plots two ranges (last year and current year) as filled
+    bands plus the latest snapshot as a marked line, with
+    the due-period axis on x and the rate/yield on y.
+
+    Parameters mirror ``LinePlot`` / ``StackedAreaPlot``
+    where applicable; visual constants (band colors, line
+    width, marker) come from ``PLOT_CONFIG['type_curve']``.
+    """
+
+    def __init__(
+        self,
+        out_path: Path,
+        data: pd.DataFrame,
+        series: dict[str, str],
+        *,
+        scale: float = 1,
+        fmt: Format | None = None,
+        legend: Legend | None = None,
+        figsize: tuple[float, float] | None = None,
+        points_to_mark: list[str] | None = None,
+    ) -> None:
+        if out_path.suffix != ".png":
+            raise ValueError(f"out_path must be .png: {out_path}")
+        if len(series) < 2:
+            raise ValueError(
+                "A type curve must have at least two due periods. "
+                f"Given: {list(series)}"
+            )
+        self.out_path = out_path
+        self.data = data
+        self.series = series
+        self.scale = scale
+        self.fmt = fmt or Format()
+        self.legend = legend
+        self.figsize = figsize
+        self.points_to_mark = points_to_mark or []
+
+    @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:
+        plot_data = self.data.loc[:, list(self.series.keys())]
+        plot_data = plot_data.rename(columns=self.series)
+        plot_data = plot_data * self.scale
+
+        formatted_assets = _format_data(plot_data)
+        formatted_data: pd.DataFrame = formatted_assets["data"]
+        due_index: pd.Index[Any] = formatted_data.index
+
+        fig_kw = dict(FIG_CONFIG)
+        if self.figsize is not None:
+            fig_kw["figsize"] = self.figsize
+        fig: Figure = plt.figure(  # type: ignore[reportUnknownMemberType]
+            **fig_kw
+        )
+        ax: Axes = fig.add_subplot()
+
+        last_config: dict[str, Any] = TYPE_CURVE_CONFIG["last"]
+        ax.fill_between(  # type: ignore[reportUnknownMemberType]
+            due_index,
+            formatted_data["last_year_min"],
+            formatted_data["last_year_max"],
+            alpha=last_config["alpha"],
+            color=last_config["color"],
+            edgecolor=None,
+            label=f"Rango {formatted_assets['last_year']}",
+        )
+
+        current_config: dict[str, Any] = TYPE_CURVE_CONFIG["current"]
+        ax.fill_between(  # type: ignore[reportUnknownMemberType]
+            due_index,
+            formatted_data["current_year_min"],
+            formatted_data["current_year_max"],
+            alpha=current_config["alpha"],
+            color=current_config["color"],
+            edgecolor=None,
+            label=f"Rango {formatted_assets['current_year']}",
+        )
+
+        line_config: dict[str, Any] = TYPE_CURVE_CONFIG["line"]
+        current = formatted_data["current_data"]
+        current.plot(
+            ax=ax,
+            color=line_config["color"],
+            linewidth=line_config["linewidth"],
+            label=formatted_assets["current_date"],
+        )
+        for code in self.points_to_mark:
+            if code not in self.series:
+                raise KeyError(
+                    f"points_to_mark entry {code!r} not in series keys: "
+                    f"{list(self.series)}"
+                )
+            label = self.series[code]
+            value: float = current.loc[label]
+            ax.plot(  # type: ignore[reportUnknownMemberType]
+                label,
+                value,
+                marker=line_config["marker"],
+                color=line_config["color"],
+            )
+            ax.annotate(  # type: ignore[reportUnknownMemberType]
+                format_annotation(value, self.fmt.decimals, self.fmt.units),
+                (label, value),  # type: ignore[reportArgumentType]
+                textcoords="offset points",
+                xytext=(0, 10),
+                ha="center",
+            )
+
+        style_spines(
+            ax,
+            decimals=self.fmt.decimals,
+            units=self.fmt.units,
+            **AX_CONFIG["spines"],
+        )
+        _rotate_xticks(ax)
+        style_baseline(ax, 0, **AX_CONFIG["baseline"])
+
+        handles, labels = ax.get_legend_handles_labels()
+        ncol = self.legend.ncol if (self.legend and self.legend.ncol) else 3
+        fig.legend(  # type: ignore[reportUnknownMemberType]
+            handles,
+            labels,
+            loc="outside lower center",
+            ncol=ncol,
+        )
+        fig.savefig(  # type: ignore[reportUnknownMemberType]
+            self.out_path
+        )
+        plt.close(fig)
+        return ax

{tesorotools_python-0.0.35 → tesorotools_python-0.0.36}/src/tesorotools/convert.py

@@ -6,9 +6,9 @@ from typing import Any
 import pandas as pd
 
 from tesorotools.artists.barh_plot import plot_barh_charts_from_flash
-from tesorotools.artists.line_plot import plot_line_charts
+from tesorotools.artists.line_plot import Format, plot_line_charts
 from tesorotools.artists.table import generate_tables_from_flash
-from tesorotools.artists.type_curve import plot_type_curves
+from tesorotools.artists.type_curve import TypeCurve
 from tesorotools.dependencies.resolution import (
     compute_derivate_series,
     concat_derivate_series,
@@ -105,5 +105,19 @@ if __name__ == "__main__":
     trimmed_df: pd.DataFrame = trim(full_df)  # type: ignore[assignment]
     plot_barh_charts_from_flash(Path("."), full_df, barh_config_dicts)
     plot_line_charts(Path("."), trimmed_df, line_config_dicts)
-    plot_type_curves(Path("."), trimmed_df, type_config_dicts)
+    for name, curve_cfg in type_config_dicts.items():
+        if name.startswith("."):
+            continue
+        yaxis_cfg: dict[str, Any] = curve_cfg.get("yaxis", {})
+        line_cfg: dict[str, Any] = curve_cfg.get("line", {})
+        TypeCurve(
+            out_path=Path(".") / f"{name}.png",
+            data=trimmed_df,
+            series=curve_cfg["series"],
+            fmt=Format(
+                units=yaxis_cfg.get("units", ""),
+                decimals=yaxis_cfg.get("decimals", 0),
+            ),
+            points_to_mark=line_cfg.get("points_to_mark"),
+        ).plot()
     generate_tables_from_flash(Path("."), full_df, table_config_dicts)

tesorotools_python-0.0.36/src/tesorotools/providers/__init__.py

@@ -0,0 +1,32 @@
+"""Public provider API.
+
+``BdeProvider`` and ``EcbProvider`` depend on the optional
+``[bde]`` / ``[ecb]`` extras (which install ``requests``)
+and are imported lazily through ``__getattr__``; importing
+``tesorotools.providers`` itself does not require those
+extras.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from tesorotools.providers.base import DataProvider
+
+if TYPE_CHECKING:
+    from tesorotools.providers.bde import BdeProvider
+    from tesorotools.providers.ecb import EcbProvider
+
+__all__ = ["BdeProvider", "DataProvider", "EcbProvider"]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "BdeProvider":
+        from tesorotools.providers.bde import BdeProvider
+
+        return BdeProvider
+    if name == "EcbProvider":
+        from tesorotools.providers.ecb import EcbProvider
+
+        return EcbProvider
+    raise AttributeError(
+        f"module 'tesorotools.providers' has no attribute {name!r}"
+    )

tesorotools_python-0.0.36/src/tesorotools/render/__init__.py

@@ -0,0 +1,22 @@
+"""Public render API."""
+
+from tesorotools.render.content.content import Content
+from tesorotools.render.content.images import Image, Images
+from tesorotools.render.content.section import Section
+from tesorotools.render.content.subtitle import Subtitle
+from tesorotools.render.content.table import Table
+from tesorotools.render.content.text import Text
+from tesorotools.render.content.title import Title
+from tesorotools.render.report import Report
+
+__all__ = [
+    "Content",
+    "Image",
+    "Images",
+    "Report",
+    "Section",
+    "Subtitle",
+    "Table",
+    "Text",
+    "Title",
+]

tesorotools_python-0.0.36/src/tesorotools/utils/config.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from tesorotools.utils.template import TemplateLoader
+
+
+def clean_config_dicts(
+    config_dicts: dict[str, Any],
+) -> dict[str, Any]:
+    return {k: v for k, v in config_dicts.items() if not k.startswith(".")}
+
+
+def read_config(
+    config_file: Path,
+    loader: type[yaml.FullLoader] | None = None,
+    clean: bool = True,
+) -> Any:
+    actual_loader: type[yaml.FullLoader] = (
+        yaml.FullLoader if loader is None else TemplateLoader
+    )
+    with open(config_file, encoding="utf8") as file:
+        config_dict: Any = yaml.load(file, Loader=actual_loader)
+        if clean and isinstance(config_dict, dict):
+            config_dict = clean_config_dicts(config_dict)  # type: ignore[reportUnknownArgumentType]
+    return config_dict
+
+
+def merge(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
+    # a overrides
+    for key in b:
+        if key in a:
+            if isinstance(a[key], dict) and isinstance(b[key], dict):
+                merge(a[key], b[key])
+        else:
+            a[key] = b[key]
+    return a

tesorotools_python-0.0.35/src/tesorotools/artists/__init__.py

@@ -1,5 +0,0 @@
-import matplotlib.style
-
-from ..utils.globals import STYLE_SHEET
-
-matplotlib.style.use(STYLE_SHEET)

tesorotools_python-0.0.35/src/tesorotools/artists/type_curve.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-import matplotlib.pyplot as plt
-import pandas as pd
-from matplotlib.axes import Axes
-from matplotlib.figure import Figure
-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,
-    format_annotation,
-    load_fonts,
-)
-
-TYPE_CURVE_CONFIG: dict[str, Any] = PLOT_CONFIG["type_curve"]
-AX_CONFIG: dict[str, Any] = PLOT_CONFIG["ax"]
-FIG_CONFIG: dict[str, Any] = PLOT_CONFIG["figure"]
-
-load_fonts()
-
-
-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",
-    )
-
-
-def _format_data(data: pd.DataFrame) -> dict[str, Any]:
-    # metadata
-    date_index: pd.DatetimeIndex = data.index  # type: ignore[assignment]
-    current_date: Timestamp = date_index.max()  # type: ignore[assignment]
-    current_year: int = current_date.year
-    last_year: int = (current_date - pd.DateOffset(years=1)).year
-
-    # current data
-    current_data: pd.Series[Any] = data.loc[current_date, :]  # type: ignore[assignment]
-    current_data.name = "current_data"
-
-    # current year
-    current_year_data: pd.DataFrame = data.loc[
-        date_index.year == current_year, :
-    ]
-    current_year_max: pd.Series[Any] = current_year_data.max()
-    current_year_max.name = "current_year_max"
-    current_year_min: pd.Series[Any] = current_year_data.min()
-    current_year_min.name = "current_year_min"
-
-    # last year
-    last_year_data: pd.DataFrame = data.loc[date_index.year == last_year, :]
-    last_year_max: pd.Series[Any] = last_year_data.max()
-    last_year_max.name = "last_year_max"
-    last_year_min: pd.Series[Any] = last_year_data.min()
-    last_year_min.name = "last_year_min"
-
-    formatted_data: pd.DataFrame = pd.concat(
-        [
-            last_year_max,
-            last_year_min,
-            current_year_max,
-            current_year_min,
-            current_data,
-        ],
-        axis=1,
-    )
-
-    return {
-        "data": formatted_data,
-        "current_date": current_date.strftime("%d/%m/%Y"),
-        "current_year": current_year,
-        "last_year": last_year,
-    }
-
-
-def _plot_current_data(
-    ax: Axes,
-    data: pd.Series[Any],
-    date_fmt: str,
-    *,
-    linewidth: float,
-    marker: str,
-    points_to_mark: list[str],
-    color: str,
-    decimals: int,
-    units: str,
-) -> None:
-    data.plot(
-        ax=ax,
-        color=color,
-        linewidth=linewidth,
-        label=date_fmt,
-    )
-    for point in points_to_mark:
-        value: float = data.loc[point]
-        ax.plot(  # type: ignore[reportUnknownMemberType]
-            point,
-            value,
-            marker=marker,
-            color=color,
-        )
-        ax.annotate(  # type: ignore[reportUnknownMemberType]
-            format_annotation(value, decimals, units),
-            (point, value),  # type: ignore[reportArgumentType]
-            textcoords="offset points",
-            xytext=(0, 10),
-            ha="center",
-        )
-
-
-def plot_type_curve(
-    data: pd.DataFrame,
-    out_file: Path,
-    **config: Any,
-) -> None:
-    merged_config: dict[str, Any] = merge(config, TYPE_CURVE_CONFIG)
-
-    if merged_config["yaxis"]["units"] == "p.b.":
-        data = data * 100
-
-    formatted_assets: dict[str, Any] = _format_data(data)
-    formatted_data: pd.DataFrame = formatted_assets["data"]
-    due_index: pd.Index[Any] = formatted_data.index
-
-    fig: Figure = plt.figure(  # type: ignore[reportUnknownMemberType]
-        **FIG_CONFIG
-    )
-    ax: Axes = fig.add_subplot()
-
-    last_config: dict[str, Any] = merged_config["last"]
-    ax.fill_between(  # type: ignore[reportUnknownMemberType]
-        due_index,
-        formatted_data["last_year_min"],
-        formatted_data["last_year_max"],
-        alpha=last_config["alpha"],
-        color=last_config["color"],
-        edgecolor=None,
-        label=f"Rango {formatted_assets['last_year']}",
-    )
-
-    current_config: dict[str, Any] = merged_config["current"]
-    ax.fill_between(  # type: ignore[reportUnknownMemberType]
-        due_index,
-        formatted_data["current_year_min"],
-        formatted_data["current_year_max"],
-        alpha=current_config["alpha"],
-        color=current_config["color"],
-        edgecolor=None,
-        label=f"Rango {formatted_assets['current_year']}",
-    )
-
-    _plot_current_data(
-        ax,
-        formatted_data["current_data"],
-        formatted_assets["current_date"],
-        **merged_config["line"],
-    )
-    style_spines(ax, **merged_config["yaxis"], **AX_CONFIG["spines"])
-    _rotate_xticks(ax)
-    style_baseline(ax, 0, **AX_CONFIG["baseline"])
-    handles, labels = ax.get_legend_handles_labels()
-    fig.legend(  # type: ignore[reportUnknownMemberType]
-        handles,
-        labels,
-        loc="outside lower center",
-        ncol=3,
-    )
-    fig.savefig(  # type: ignore[reportUnknownMemberType]
-        out_file
-    )
-
-
-# data is expected to be a simple time series data, columns are series and rows represents dates
-def plot_type_curves(
-    out_path: Path,
-    data: pd.DataFrame,
-    config_dicts: dict[str, Any],
-) -> None:
-    for name, config in config_dicts.items():
-        if not name.startswith("."):  # aux entries
-            series: dict[str, str] = config["series"]
-            if len(series) < 2:
-                raise ValueError(
-                    f"In plot {name}: A type curve must have at least two due periods. Given periods: {series.keys()}"
-                )
-            trimmed_data: pd.DataFrame = data.loc[:, series.keys()]
-            trimmed_data = trimmed_data.rename(columns=series)
-            plot_type_curve(
-                data=trimmed_data,
-                out_file=out_path / f"{name}.png",
-                **config,
-            )

tesorotools_python-0.0.35/src/tesorotools/utils/config.py

@@ -1,98 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from tesorotools.utils.template import TemplateLoader
-
-_tags_registered = False
-
-
-def _register_all_tags() -> None:
-    """Register every YAML tag on TemplateLoader.
-
-    Called once, lazily, the first time ``read_config`` is
-    invoked with ``loader=TemplateLoader``.  This removes
-    the need for consumers to import ``tesorotools.render``
-    or ``tesorotools.artists`` just for their side effects.
-    """
-    global _tags_registered  # noqa: PLW0603
-    if _tags_registered:
-        return
-    _tags_registered = True
-
-    # -- artists tags --
-    from tesorotools.artists.barh_plot import (
-        HorizontalBarChart,
-    )
-    from tesorotools.artists.line_plot import (
-        Format,
-        Legend,
-        LinePlot,
-    )
-    from tesorotools.artists.stacked import (
-        StackedAreaPlot,
-        StackedBarPlot,
-    )
-
-    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)
-    TemplateLoader.add_constructor("!barh", HorizontalBarChart.from_yaml)
-
-    # -- render tags --
-    from tesorotools.render.content.images import (
-        Image,
-        Images,
-    )
-    from tesorotools.render.content.section import Section
-    from tesorotools.render.content.subtitle import Subtitle
-    from tesorotools.render.content.table import Table
-    from tesorotools.render.content.text import Text
-    from tesorotools.render.content.title import Title
-    from tesorotools.render.report import Report
-
-    TemplateLoader.add_constructor("!report", Report.from_yaml)
-    TemplateLoader.add_constructor("!section", Section.from_yaml)
-    TemplateLoader.add_constructor("!image", Image.from_yaml)
-    TemplateLoader.add_constructor("!images", Images.from_yaml)
-    TemplateLoader.add_constructor("!table", Table.from_yaml)
-    TemplateLoader.add_constructor("!text", Text.from_yaml)
-    TemplateLoader.add_constructor("!title", Title.from_yaml)
-    TemplateLoader.add_constructor("!subtitle", Subtitle.from_yaml)
-
-
-def clean_config_dicts(
-    config_dicts: dict[str, Any],
-) -> dict[str, Any]:
-    return {k: v for k, v in config_dicts.items() if not k.startswith(".")}
-
-
-def read_config(
-    config_file: Path,
-    loader: type[yaml.FullLoader] | None = None,
-    clean: bool = True,
-) -> Any:
-    actual_loader: type[yaml.FullLoader] = (
-        yaml.FullLoader if loader is None else TemplateLoader
-    )
-    if actual_loader is TemplateLoader:
-        _register_all_tags()
-    with open(config_file, encoding="utf8") as file:
-        config_dict: Any = yaml.load(file, Loader=actual_loader)
-        if clean and isinstance(config_dict, dict):
-            config_dict = clean_config_dicts(config_dict)  # type: ignore[reportUnknownArgumentType]
-    return config_dict
-
-
-def merge(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
-    # a overrides
-    for key in b:
-        if key in a:
-            if isinstance(a[key], dict) and isinstance(b[key], dict):
-                merge(a[key], b[key])
-        else:
-            a[key] = b[key]
-    return a