tesorotools-python 0.0.18__py3-none-any.whl

tesorotools/render/content/subtitle.py

@@ -0,0 +1,53 @@
+from datetime import date, datetime, time
+from typing import Any, Self
+
+from babel.dates import format_datetime
+from docx.document import Document
+from yaml import MappingNode
+
+from tesorotools.utils.config import TemplateLoader
+
+
+class Subtitle:
+    def __init__(self, date_time: datetime | None = None) -> None:
+        if date_time is None:
+            date_time: datetime = datetime.now()
+        self._date_time: datetime = date_time
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        subtitle_cfg: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        # parse date
+        date_cfg: str | date | None = subtitle_cfg.get("date", None)
+        if date_cfg is None:
+            date_time: datetime = datetime.now()
+        elif isinstance(date_cfg, date):
+            date_time: datetime = datetime.combine(date_cfg, time.min)
+        elif isinstance(date_cfg, str):
+            date_time: datetime = datetime.strptime(date_cfg, "%Y-%m-%d")
+
+        # parse hour
+        hour_cfg: str | None = subtitle_cfg.get("hour", None)
+        if hour_cfg is not None:
+            hour_str, minute_str = hour_cfg.split(sep=":")
+            date_time = date_time.replace(
+                hour=int(hour_str), minute=int(minute_str)
+            )
+
+        return cls(date_time)
+
+    def set_time(self, hour: int, minute: int) -> None:
+        self._date_time = self._date_time.replace(hour=hour, minute=minute)
+
+    def _format_datetime(self) -> str:
+        date_fmt: str = format_datetime(
+            self._date_time, "EEEE, dd 'de' MMMM 'de' yyyy, HH:mm", locale="es"
+        )
+        date_fmt = date_fmt.capitalize()
+        return date_fmt
+
+    def render(self, document: Document) -> Document:
+        date_fmt = self._format_datetime()
+        document.add_paragraph(date_fmt, style="Subtitle")
+        document.add_paragraph()
+        return document

tesorotools/render/content/table.py

@@ -0,0 +1,308 @@
+from pathlib import Path
+from typing import Any, Self
+
+import numpy as np
+import pandas as pd
+from docx.document import Document
+from docx.enum.table import WD_ALIGN_VERTICAL, WD_TABLE_ALIGNMENT
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.oxml import OxmlElement, parse_xml
+from docx.oxml.ns import nsdecls, qn
+from docx.shared import Inches, Pt, RGBColor
+from docx.table import Table as TableDocx
+from docx.table import _Cell as TableCell
+from yaml import MappingNode
+
+from tesorotools.utils.config import read_config
+from tesorotools.utils.globals import PLOT_CONFIG_FILE
+from tesorotools.utils.template import TemplateLoader
+
+RENDER_CONFIG: dict[str, Any] = read_config(PLOT_CONFIG_FILE)["table"]
+
+TEXTO_TABLAS = 9
+
+CENTER = WD_ALIGN_PARAGRAPH.CENTER
+
+
+def _set_cell_border(cell: TableCell, **kwargs):
+    """
+    Set cell`s border
+    Usage:
+
+    set_cell_border(
+        cell,
+        top={"sz": 12, "val": "single", "color": "#FF0000", "space": "0"},
+        bottom={"sz": 12, "color": "#00FF00", "val": "single"},
+        start={"sz": 24, "val": "dashed", "shadow": "true"},
+        end={"sz": 12, "val": "dashed"},
+    )
+    """
+    tc = cell._tc
+    tcPr = tc.get_or_add_tcPr()
+
+    # check for tag existence, if none found, create one
+    tcBorders = tcPr.first_child_found_in("w:tcBorders")
+    if tcBorders is None:
+        tcBorders = OxmlElement("w:tcBorders")
+        tcPr.append(tcBorders)
+
+    # list over all available tags
+    for edge in ("start", "top", "end", "bottom", "insideH", "insideV"):
+        edge_data = kwargs.get(edge)
+        if edge_data:
+            tag = "w:{}".format(edge)
+
+            # check for tag existence, if none found, then create one
+            element = tcBorders.find(qn(tag))
+            if element is None:
+                element = OxmlElement(tag)
+                tcBorders.append(element)
+
+            # looks like order of attributes is important
+            for key in ["sz", "val", "color", "space", "shadow"]:
+                if key in edge_data:
+                    element.set(qn("w:{}".format(key)), str(edge_data[key]))
+
+
+def _style_horizontal_blocks_header(cell: TableCell):
+    cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
+    cell.paragraphs[0].runs[0].font.size = Pt(12)
+
+
+def _horizontal_blocks_header(columns: pd.MultiIndex, table_docx: TableDocx):
+    column_counter: int = 1
+    blocks: list[str] = list(columns.get_level_values(level=0).unique())
+    for block in blocks:
+        cell: TableCell = table_docx.cell(0, column_counter)
+        columns_to_merge: int = len(
+            columns[columns.get_level_values(level=0) == block]
+        )
+        for _ in range(columns_to_merge - 1):
+            column_counter = column_counter + 1
+            cell.merge(table_docx.cell(0, column_counter))
+        column_counter = column_counter + 1
+        cell.text = block
+        _style_horizontal_blocks_header(cell)
+
+
+def _style_column_names(cell: TableCell):
+    cell.paragraphs[0].runs[0].font.size = Pt(10)
+    cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+
+def _fill_column_names(
+    table: pd.DataFrame, table_docx: TableDocx, horizontal: bool
+):
+    if horizontal:
+        start_row: int = 1
+        _horizontal_blocks_header(table.columns, table_docx)
+        columns: np.ndarray = table.columns.get_level_values(level=1).values
+    else:
+        start_row: int = 0
+        columns: np.ndarray = table.columns.values
+
+    for idx, column_name in enumerate(columns, start=1):
+        cell: TableCell = table_docx.cell(start_row, idx)
+        cell.text = column_name
+        _style_column_names(cell)
+
+
+def _style_index_names(cell: TableCell):
+    cell.paragraphs[0].runs[0].font.size = Pt(TEXTO_TABLAS)
+    cell.paragraphs[0].runs[0].font.bold = True
+    cell.width = Inches(1)
+
+
+def _fill_index_names(
+    index: pd.Index | pd.MultiIndex, table_docx: TableDocx, horizontal: bool
+):
+    start_row: int = 2 if horizontal else 1
+
+    index_names: pd.Index = (
+        index
+        if (horizontal or (not isinstance(index, pd.MultiIndex)))
+        else index.get_level_values(level=1)
+    )
+
+    for idx, name in enumerate(index_names, start=start_row):
+        cell: TableCell = table_docx.cell(idx, 0)
+        cell.text = name
+        _style_index_names(cell)
+
+
+# we only separate blocks in vertically stacked tables
+def _separate_blocks(index: pd.MultiIndex, table_docx: TableDocx):
+    blocks: list[str] = list(index.get_level_values(level=0).unique())
+    previous_rows = 0
+    for block in blocks[:-1]:
+        block_size: int = len(index[index.get_level_values(level=0) == block])
+        for cell in table_docx.rows[block_size + previous_rows].cells:
+            _separate_cell(cell)
+        previous_rows += block_size
+
+
+def _separate_cell(cell: TableCell):
+    _set_cell_border(
+        cell,
+        bottom={
+            "sz": 1,
+            "val": "double",
+            "color": "#000000",
+            "space": 2,
+        },
+    )
+
+
+def _is_bright(hex_color):
+    red = int(hex_color[:2], 16)
+    green = int(hex_color[2:4], 16)
+    blue = int(hex_color[4:], 16)
+    luminance = 0.2126 * red + 0.7152 * green + 0.0722 * blue
+    return luminance > 180
+
+
+def _shade_cell(cell: TableCell, hex_color: str):
+    bright = _is_bright(hex_color)
+    shading_element = parse_xml(
+        r'<w:shd {} w:fill="{hex_color}"/>'.format(
+            nsdecls("w"), hex_color=hex_color
+        )
+    )
+    cell._tc.get_or_add_tcPr().append(shading_element)
+    if bright:
+        cell.paragraphs[0].runs[0].font.color.rgb = RGBColor(0, 0, 0)
+    else:
+        cell.paragraphs[0].runs[0].font.color.rgb = RGBColor(255, 255, 255)
+
+
+def _style_content(cell: TableCell):
+    cell.paragraphs[0].runs[0].font.size = Pt(TEXTO_TABLAS)
+    cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.RIGHT
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+
+def _fill_content(
+    table: pd.DataFrame,
+    color_table: pd.DataFrame,
+    shade_table: pd.DataFrame,
+    table_docx: TableDocx,
+    horizontal: bool,
+):
+    start_row: int = 2 if horizontal else 1
+    values = table.values
+    for (x, y), value in np.ndenumerate(values):
+        cell: TableCell = table_docx.cell(x + start_row, y + 1)
+        cell.text = value if value is not None else ""
+        color: str | None = (
+            color_table.values[x, y] if color_table is not None else None
+        )
+        shade: str | None = (
+            shade_table.values[x, y] if shade_table is not None else None
+        )
+        if color is not None:
+            cell.paragraphs[0].runs[0].font.color.rgb = RGBColor.from_string(
+                color
+            )
+        if shade is not None:
+            _shade_cell(cell, shade)
+        _style_content(cell)
+
+
+def _style_table(table_docx: TableDocx):
+    table_docx.style = RENDER_CONFIG.get("style", None)
+    table_docx.autofit = RENDER_CONFIG["autofit"]
+
+
+def render_table(
+    table: pd.DataFrame,
+    color_table: pd.DataFrame,
+    shade_table: pd.DataFrame,
+    document: Document,
+    block_sep: bool,
+    **kwargs,
+) -> TableDocx:
+
+    horizontal: bool = isinstance(table.columns, pd.MultiIndex)
+    table_docx: TableDocx = document.add_table(
+        rows=len(table.index) + table.columns.nlevels,
+        cols=len(table.columns) + 1,
+    )
+
+    _style_table(table_docx)
+    _fill_column_names(table, table_docx, horizontal)
+    _fill_index_names(
+        index=table.index, table_docx=table_docx, horizontal=horizontal
+    )
+    if block_sep:
+        _separate_blocks(table.index, table_docx)
+    _fill_content(table, color_table, shade_table, table_docx, horizontal)
+    table_docx.alignment = WD_TABLE_ALIGNMENT.CENTER
+    return document
+
+
+class Table:
+    """A rendered table in the document"""
+
+    def __init__(
+        self,
+        data_file: Path | None = None,
+        color_file: Path | None = None,
+        shade_file: Path | None = None,
+        block_sep: bool = False,
+        title: str | None = None,
+    ):
+        if (
+            (data_file is None)
+            and (color_file is None)
+            and (shade_file is None)
+        ):
+            raise ValueError("At least a piece of data should be given")
+        self._data: pd.DataFrame | None = (
+            pd.read_feather(data_file) if data_file is not None else None
+        )
+        self._color: pd.DataFrame | None = (
+            pd.read_feather(color_file) if color_file is not None else None
+        )
+        self._shade: pd.DataFrame | None = (
+            pd.read_feather(shade_file) if shade_file is not None else None
+        )
+        self._title: str | None = title
+        self._block_sep: bool = block_sep
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        table_cfg: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        root_path: Path = loader.imports["table"]
+        file_prefix: str = table_cfg.pop("id")
+
+        # the data file has an optional "_data" suffix
+        # if a file with the suffix exists, it will be preferred
+        data_file_suffix: Path = root_path / f"{file_prefix}_data.feather"
+        if data_file_suffix.exists():
+            data_file: Path = data_file_suffix
+        else:
+            data_file: Path = root_path / f"{file_prefix}.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=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:
+        heading = document.add_heading(self._title, level=2)
+        heading.alignment = CENTER
+        heading.runs[0].font.size = Pt(10)
+
+        render_table(
+            self._data,
+            self._color,
+            self._shade,
+            document,
+            block_sep=self._block_sep,
+        )
+        return document

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/render/content/title.py

@@ -0,0 +1,40 @@
+from typing import Any, Self
+
+from docx.document import Document
+from yaml import MappingNode
+
+from tesorotools.utils.config import TemplateLoader
+
+
+class Title:
+    def __init__(
+        self, title: str | None = None, comment: str | None = None
+    ) -> None:
+        self._title: str = "" if title is None else title
+        self._comment: str = "" if comment is None else comment
+
+    @classmethod
+    def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
+        title_cfg: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        title: str | None = title_cfg.get("title", None)
+        comment: str | None = title_cfg.get("comment", None)
+        return cls(title, comment)
+
+    def render(self, document: Document) -> Document:
+        if (self.title == "") and (self.comment == ""):
+            title_text: str = ""
+        elif (self.title == "") and (self.comment != ""):
+            title_text: str = self.comment
+        else:
+            title_text: str = f"{self.title}: {self.comment}"
+        # Use the "Title" style in the word template
+        document.add_heading(text=title_text, level=0)
+        return document
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @property
+    def comment(self) -> str:
+        return self._comment

tesorotools/render/report.py

@@ -0,0 +1,31 @@
+from typing import Any, Self
+
+from docx.document import Document
+from yaml import Loader, MappingNode
+
+from tesorotools.render.content.content import Content
+from tesorotools.render.content.title import Title
+
+
+class Report:
+    def __init__(
+        self,
+        title: str,
+        contents: dict[str, Content],
+    ):
+        self.title: str = title
+        self.contents: dict[str, Content] = contents
+
+    @classmethod
+    def from_yaml(cls, loader: Loader, node: MappingNode) -> Self:
+        report_cfg: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        title: str = report_cfg.pop("id")
+        return cls(title=title, contents=report_cfg)
+
+    def render(self, document: Document) -> Document:
+        document._body.clear_content()
+        for _, content in self.contents.items():
+            content.render(document)
+            if not isinstance(content, Title):
+                document.add_paragraph()
+        return document

tesorotools/utils/config.py

@@ -0,0 +1,35 @@
+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]):
+    if config_dicts is None:
+        return None
+    return {k: v for k, v in config_dicts.items() if not k.startswith(".")}
+
+
+# maybe a dedicated function for templates would be nice
+def read_config(
+    config_file: Path, loader: yaml.FullLoader = None, clean: bool = True
+) -> Any | dict:
+    loader = yaml.FullLoader if loader is None else TemplateLoader
+    with open(config_file, encoding="utf8") as file:
+        config_dict = yaml.load(file, Loader=loader)
+        if clean and isinstance(config_dict, dict):
+            config_dict = clean_config_dicts(config_dict)
+    return config_dict
+
+
+def merge(a: dict, b: dict):
+    # 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/utils/globals.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+BASE_PATH: Path = Path(__file__).parent.parent
+
+DEBUG: Path = Path("debug")
+CONFIG: Path = Path("config")
+EXAMPLES: Path = Path("examples")
+
+# various assets for the plots
+ASSETS: Path = BASE_PATH / "assets"
+FONTS: Path = ASSETS / "fonts"
+STYLE_SHEET: Path = ASSETS / "tesoro.mplstyle"
+
+PLOT_CONFIG_FILE: Path = ASSETS / "plots.yaml"

tesorotools/utils/matplotlib.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+import matplotlib
+import matplotlib.font_manager
+
+from .config import read_config
+from .globals import FONTS, PLOT_CONFIG_FILE
+
+# this should only be done once
+PLOT_CONFIG: dict[str, Any] = read_config(PLOT_CONFIG_FILE)
+
+
+def load_fonts() -> None:
+    for font in FONTS.iterdir():
+        if font.suffix == ".otf":
+            matplotlib.font_manager.fontManager.addfont(font)
+    matplotlib.rcParams["font.family"] = PLOT_CONFIG["style"]["font"]
+
+
+# this is not really matplotlib specific, so it should be elsewhere
+def format_annotation(value: float, decimals: int, units: str) -> str:
+    decimal_formatted: str = f"{value:_.{decimals}f}".replace(".", ",").replace(
+        "_", "."
+    )
+    decimal_formatted = (
+        decimal_formatted[1:]
+        if (decimal_formatted.startswith("-0") and decimals == 0)
+        else decimal_formatted
+    )
+    return f"{decimal_formatted}{units}"
+
+
+def is_zero(value: float, decimals: int) -> bool:
+    formatted = format_annotation(value, decimals, units="")
+    unique = "".join(set(formatted.replace(",", "").replace(".", "")))
+    if unique == "0":
+        return True
+    return False

tesorotools/utils/series.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from tesorotools.dependencies.node import Node
+from tesorotools.dependencies.resolution import resolve_series
+
+
+def compile_series(
+    config_dicts: list[dict[str, Any]],
+    dependencies_cfg: dict[str, Any],
+    out: Path,
+) -> dict[str, list[str]]:
+    """Generates a document with all the series used in the document. Useful when you want to download them all at once."""
+
+    resolved_dict = resolve_series(
+        config_dicts,
+        dependencies_cfg,
+    )
+
+    dependent_series: list[Node] = resolved_dict["dependent"]
+    dependent_series_id_list: list[str] = [
+        node.name for node in dependent_series
+    ]
+    independent_series_id_list: list[str] = list(resolved_dict["independent"])
+    result = {
+        "dependent": dependent_series_id_list,
+        "independent": independent_series_id_list,
+    }
+
+    with open(out, "w", encoding="utf-8") as stream:
+        comment: str = "# Autogenerated document, do not touch!\n\n"
+        stream.write(comment)
+        yaml.dump(
+            result,
+            stream,
+        )
+
+    return result

tesorotools/utils/shortcuts.py

@@ -0,0 +1,32 @@
+import platform
+from pathlib import Path
+
+import win32com.client
+from win32com.client import CDispatch
+
+
+# this a good candidate to be added to tesorotools-python
+def resolve_shortcut(shortcut: Path) -> Path:
+    """Returns the real path behind a shortcut
+
+    Parameters
+    ----------
+    shortcut : Path
+        Path of the shortcut
+
+    Returns
+    -------
+    Path
+        Real path behind the shortcut
+    """
+    system: str = platform.system()
+    if system == "Linux":
+        # In linux this is straightforward
+        return shortcut
+    elif system == "Windows":
+        # Little workaround with windows
+        shell: CDispatch = win32com.client.Dispatch("WScript.Shell")
+        return Path(shell.CreateShortCut(str(shortcut)).Targetpath)
+    else:
+        # Just return the same if we don't know the OS
+        return shortcut