tesorotools-python 0.0.9__tar.gz → 0.0.11__tar.gz

{tesorotools_python-0.0.9 → tesorotools_python-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tesorotools-python
-Version: 0.0.9
+Version: 0.0.11
 Requires-Dist: babel
 Requires-Dist: eikon
 Requires-Dist: lseg-data

{tesorotools_python-0.0.9 → tesorotools_python-0.0.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tesorotools-python"
-version = "0.0.9"
+version = "0.0.11"
 dependencies = ["psycopg2", "SQLAlchemy", "pandas", "matplotlib", "pyarrow", "python-docx", "openpyxl", "PyYAML", "babel", "eikon", "lseg-data"]
 
 [build-system]

tesorotools_python-0.0.11/tesorotools/__init__.py

@@ -0,0 +1,6 @@
+from tesorotools.artists.line_plot import Format, Legend, LinePlot
+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)

tesorotools_python-0.0.11/tesorotools/artists/line_plot.py

@@ -0,0 +1,243 @@
+import datetime
+import locale
+from pathlib import Path
+from typing import Any, Self
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib.ticker import FuncFormatter
+from yaml.nodes import MappingNode
+
+from tesorotools.utils.config import TemplateLoader
+
+locale.setlocale(locale.LC_ALL, "")
+
+from tesorotools.utils.globals import DEBUG
+from tesorotools.utils.matplotlib import (
+    PLOT_CONFIG,
+    format_annotation,
+    load_fonts,
+)
+
+load_fonts()
+
+LINE_PLOT_CONFIG: dict[str, Any] = PLOT_CONFIG["line"]
+AX_CONFIG: dict[str, Any] = PLOT_CONFIG["ax"]
+FIG_CONFIG: dict[str, Any] = PLOT_CONFIG["figure"]
+
+
+def _style_spines(
+    ax: plt.Axes,
+    decimals: int,
+    units: str,
+    *,
+    color: str,
+    linewidth: str,
+):
+    ax.grid(visible=True, axis="y")
+    for spine in ax.spines.values():
+        spine.set_color(color)
+        spine.set_linewidth(linewidth)
+    ax.yaxis.tick_right()
+    ax.yaxis.set_major_formatter(
+        FuncFormatter(lambda y, _: format_annotation(y, decimals, units))
+    )
+    ax.set_xlabel("")
+
+    ax.tick_params(which="minor", size=0, width=0)
+    ax.tick_params(axis="both", which="major")
+    for tick in ax.get_xticklines():
+        tick.set_markeredgecolor(color)
+    for tick in ax.get_yticklines():
+        tick.set_markeredgecolor(color)
+
+
+def _style_baseline(ax: plt.Axes, reference: float = 0, **baseline_config):
+    color: str = baseline_config["color"]
+    bottom_lim, top_lim = ax.get_ylim()
+    ax.set_ylim(bottom=min(reference, bottom_lim), top=max(reference, top_lim))
+    bottom_lim, top_lim = ax.get_ylim()
+    if bottom_lim == reference:
+        ax.spines["bottom"].set_edgecolor(color)
+    elif top_lim == reference:
+        ax.spines["top"].set_edgecolor(color)
+    else:
+        ax.axhline(y=reference, **baseline_config)
+
+
+def plot_line_chart(
+    out_name: Path,
+    data: pd.DataFrame,
+    *,
+    base_100: bool,
+    annotate: bool,
+    format: dict[str, Any],
+    **kwargs,
+):
+    if base_100:
+        data = data / data.iloc[0, :] * 100
+    if format["units"] == "p.b.":
+        data = data * 100
+    fig = plt.figure(**FIG_CONFIG)
+    ax = fig.add_subplot()
+    data.plot(ax=ax)
+    if annotate:
+        pass
+
+    reference = 100 if base_100 else 0
+    _style_spines(ax, **format, **AX_CONFIG["spines"])
+    _style_baseline(ax, reference, **AX_CONFIG["baseline"])
+    ax.legend(
+        loc="upper center",
+        bbox_to_anchor=(0.5, LINE_PLOT_CONFIG["legend_sep"]),
+        ncol=(
+            kwargs["legend"]["ncol"]
+            if kwargs is not None and kwargs.get("legend", None) is not None
+            else LINE_PLOT_CONFIG["ncol"]
+        ),
+    )
+
+    fig.savefig(out_name)
+
+
+def plot_line_charts(data: pd.DataFrame, config_dicts: dict[str, Any]):
+    for name, config in config_dicts.items():
+        start_date: pd.Timestamp = pd.to_datetime(config["start_date"])
+        end_date_str: str | None = config["end_date"]
+        end_date: pd.Timestamp = (
+            data.index.max()
+            if end_date_str is None
+            else pd.to_datetime(end_date_str)
+        )
+        series: dict[str, str] = config["series"]
+        trimmed_data: pd.DataFrame = data.loc[
+            slice(start_date, end_date), series.keys()
+        ]
+        trimmed_data = trimmed_data.rename(columns=series)
+        out_name: Path = DEBUG / "line" / f"{name}.png"
+        plot_line_chart(out_name, trimmed_data, **config)
+
+
+class Format:
+    def __init__(self, units: str = "", decimals: int = 0):
+        self.units = units
+        self.decimals = decimals
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        loader.flatten_mapping(node)
+        format_cfg: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        format_cfg.pop("id")
+        return cls(**format_cfg)
+
+
+class Legend:
+    def __init__(self, ncol: int = 5, sep: float = -0.125):
+        self.ncol = ncol
+        self.sep = sep
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        legend_cfg: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        legend_cfg.pop("id")
+        return cls(**legend_cfg)
+
+
+# as more stuff is needed, seems wise to make a class
+class LinePlot:
+    def __init__(
+        self,
+        out_path: Path,
+        data_path: Path,
+        series: dict[str, str],
+        scale: float = 1,
+        start_date: datetime.datetime | None = None,
+        end_date: datetime.datetime | None = None,
+        base_100: bool = False,
+        annotate: bool = False,
+        baseline: bool = False,
+        format: Format | None = None,
+        legend: Legend | 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)
+
+        self.base_100 = base_100
+        self.annotate = annotate  # unused for the moment
+        self.format = format
+        self.start_date = start_date
+        self.end_date = end_date
+        self.series = series
+        self.legend = legend
+        self.baseline = baseline
+        self.scale = scale
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        line_plot_cfg: dict[str, Any] = loader.construct_mapping(
+            node, deep=True
+        )
+        line_plot_cfg.pop("id")
+        line_plot_cfg["out_path"] = Path(line_plot_cfg["out_path"])
+        line_plot_cfg["data_path"] = Path(line_plot_cfg["data_path"])
+        return cls(**line_plot_cfg)
+
+    def plot(self) -> plt.Axes:
+        start_date: pd.Timestamp = (
+            self.data.index.min()
+            if self.start_date is None
+            else pd.to_datetime(self.start_date)
+        )
+
+        end_date: pd.Timestamp = (
+            self.data.index.max()
+            if self.end_date is None
+            else pd.to_datetime(self.end_date)
+        )
+
+        plot_data: pd.DataFrame = self.data.loc[
+            slice(start_date, end_date), self.series.keys()
+        ]
+        plot_data = plot_data.rename(columns=self.series)
+
+        plot_data = plot_data * self.scale
+
+        if self.base_100:  # maybe more flexible in the future
+            plot_data = plot_data / plot_data.iloc[0, :] * 100
+
+        fig = plt.figure(**FIG_CONFIG)
+        ax = fig.add_subplot()
+        plot_data.plot(ax=ax)
+
+        if self.annotate:  # not implemented yet
+            pass
+
+        _style_spines(  # maybe make this function accept a Format object
+            ax,
+            decimals=self.format.decimals,
+            units=self.format.units,
+            **AX_CONFIG["spines"],
+        )
+        if self.baseline:
+            reference = 100 if self.base_100 else 0
+            _style_baseline(ax, reference, **AX_CONFIG["baseline"])
+
+        if self.legend is not None:
+            ax.legend(
+                loc="upper center",
+                bbox_to_anchor=(0.5, LINE_PLOT_CONFIG["legend_sep"]),
+                ncol=self.legend.ncol,
+            )
+        else:
+            ax.legend().set_visible(False)
+
+        fig.savefig(self.out_path)
+        return ax

{tesorotools_python-0.0.9 → tesorotools_python-0.0.11}/tesorotools/render/__init__.py

@@ -1,6 +1,7 @@
 from tesorotools.render.content.images import Image, Images
 from tesorotools.render.content.section import Section
 from tesorotools.render.content.table import Table
+from tesorotools.render.content.text import Text
 from tesorotools.render.report import Report
 from tesorotools.utils.template import TemplateLoader
 
@@ -9,3 +10,4 @@ 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)

{tesorotools_python-0.0.9 → tesorotools_python-0.0.11}/tesorotools/render/content/table.py

@@ -239,9 +239,9 @@ class Table:
 
     def __init__(
         self,
-        data_file: Path | None,
-        color_file: Path | None,
-        shade_file: Path | None,
+        data_file: Path | None = None,
+        color_file: Path | None = None,
+        shade_file: Path | None = None,
         block_sep: bool = False,
         title: str | None = None,
     ):
@@ -271,7 +271,12 @@ class Table:
         data_file: Path = root_path / f"{file_prefix}_data.feather"
         color_file: Path = root_path / f"{file_prefix}_color.feather"
         shade_file: Path = root_path / f"{file_prefix}_shade.feather"
-        return cls(data_file, color_file, shade_file, **table_cfg)
+        return cls(
+            data_file,
+            color_file=color_file if color_file.exists() else None,
+            shade_file=shade_file if shade_file.exists() else None,
+            **table_cfg,
+        )
 
     def render(self, document: Document) -> Document:
         document = render_table(

tesorotools_python-0.0.11/tesorotools/render/content/text.py

@@ -0,0 +1,23 @@
+from typing import Any, Self
+
+from docx.document import Document
+from yaml import Loader, MappingNode
+
+from tesorotools.render.content.content import Content
+
+
+class Text:
+    def __init__(self, text: str) -> None:
+        self._text = text
+
+    @classmethod
+    def from_yaml(cls, loader: Loader, node: MappingNode) -> Self:
+        values: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        values.pop("id")
+        text: str = values.pop("text", None)
+        section: Self = cls(text=text)
+        return section
+
+    def render(self, document: Document) -> Document:
+        document.add_paragraph(self._text)
+        return document

tesorotools_python-0.0.9/tesorotools/artists/line_plot.py

@@ -1,114 +0,0 @@
-import locale
-from pathlib import Path
-from typing import Any
-
-import matplotlib.pyplot as plt
-import pandas as pd
-from matplotlib.ticker import FuncFormatter
-
-locale.setlocale(locale.LC_ALL, "")
-
-from tesorotools.utils.globals import DEBUG
-from tesorotools.utils.matplotlib import (
-    PLOT_CONFIG,
-    format_annotation,
-    load_fonts,
-)
-
-load_fonts()
-
-LINE_PLOT_CONFIG: dict[str, Any] = PLOT_CONFIG["line"]
-AX_CONFIG: dict[str, Any] = PLOT_CONFIG["ax"]
-FIG_CONFIG: dict[str, Any] = PLOT_CONFIG["figure"]
-
-
-def _style_spines(
-    ax: plt.Axes,
-    decimals: int,
-    units: str,
-    *,
-    color: str,
-    linewidth: str,
-):
-    ax.grid(visible=True, axis="y")
-    for spine in ax.spines.values():
-        spine.set_color(color)
-        spine.set_linewidth(linewidth)
-    ax.yaxis.tick_right()
-    ax.yaxis.set_major_formatter(
-        FuncFormatter(lambda y, _: format_annotation(y, decimals, units))
-    )
-    ax.set_xlabel("")
-
-    ax.tick_params(which="minor", size=0, width=0)
-    ax.tick_params(axis="both", which="major")
-    for tick in ax.get_xticklines():
-        tick.set_markeredgecolor(color)
-    for tick in ax.get_yticklines():
-        tick.set_markeredgecolor(color)
-
-
-def _style_baseline(ax: plt.Axes, reference: float = 0, **baseline_config):
-    color: str = baseline_config["color"]
-    bottom_lim, top_lim = ax.get_ylim()
-    ax.set_ylim(bottom=min(reference, bottom_lim), top=max(reference, top_lim))
-    bottom_lim, top_lim = ax.get_ylim()
-    if bottom_lim == reference:
-        ax.spines["bottom"].set_edgecolor(color)
-    elif top_lim == reference:
-        ax.spines["top"].set_edgecolor(color)
-    else:
-        ax.axhline(y=reference, **baseline_config)
-
-
-def plot_line_chart(
-    out_name: Path,
-    data: pd.DataFrame,
-    *,
-    base_100: bool,
-    annotate: bool,
-    format: dict[str, Any],
-    **kwargs,
-):
-    if base_100:
-        data = data / data.iloc[0, :] * 100
-    if format["units"] == "p.b.":
-        data = data * 100
-    fig = plt.figure(**FIG_CONFIG)
-    ax = fig.add_subplot()
-    data.plot(ax=ax)
-    if annotate:
-        pass
-
-    reference = 100 if base_100 else 0
-    _style_spines(ax, **format, **AX_CONFIG["spines"])
-    _style_baseline(ax, reference, **AX_CONFIG["baseline"])
-    ax.legend(
-        loc="upper center",
-        bbox_to_anchor=(0.5, LINE_PLOT_CONFIG["legend_sep"]),
-        ncol=(
-            kwargs["legend"]["ncol"]
-            if kwargs is not None and kwargs.get("legend", None) is not None
-            else LINE_PLOT_CONFIG["ncol"]
-        ),
-    )
-
-    fig.savefig(out_name)
-
-
-def plot_line_charts(data: pd.DataFrame, config_dicts: dict[str, Any]):
-    for name, config in config_dicts.items():
-        start_date: pd.Timestamp = pd.to_datetime(config["start_date"])
-        end_date_str: str | None = config["end_date"]
-        end_date: pd.Timestamp = (
-            data.index.max()
-            if end_date_str is None
-            else pd.to_datetime(end_date_str)
-        )
-        series: dict[str, str] = config["series"]
-        trimmed_data: pd.DataFrame = data.loc[
-            slice(start_date, end_date), series.keys()
-        ]
-        trimmed_data = trimmed_data.rename(columns=series)
-        out_name: Path = DEBUG / "line" / f"{name}.png"
-        plot_line_chart(out_name, trimmed_data, **config)