tesorotools-python 0.0.0__py2.py3-none-any.whl

tesorotools/render/content/section.py

@@ -0,0 +1,53 @@
+from typing import Any, Self
+
+from docx.document import Document
+from yaml import Loader, MappingNode
+
+from tesorotools.render.content.content import Content
+
+
+class Section:
+    def __init__(
+        self,
+        id: str,
+        title: str | None = None,
+        contents: dict[str, Content] | None = None,
+    ) -> None:
+        self._id: str = id
+        self._title: str = title if title is not None else ""
+        self._contents: dict[str, Content] = (
+            contents if contents is not None else {}
+        )
+        self._level = 1
+
+    @property
+    def level(self) -> int:
+        return self._level
+
+    @level.setter
+    def level(self, level: int) -> None:
+        self._level = level
+
+    @classmethod
+    def from_yaml(cls, loader: Loader, node: MappingNode) -> Self:
+        values: dict[str, Any] = loader.construct_mapping(node, deep=True)
+        id: str = values.pop("id")
+        title: str = values.pop("title", None)
+        contents: dict[str, Content] = values
+        section: Self = cls(id=id, title=title, contents=contents)
+        section.nest()
+        return section
+
+    def render(self, document: Document) -> Document:
+        # Use the "Heading `level`" style from the base document
+        document.add_heading(self._title, level=self._level)
+        for _, content in self._contents.items():
+            document.add_paragraph()
+            document = content.render(document)
+        return document
+
+    def nest(self):
+        for _, content in self._contents.items():
+            if isinstance(content, Section):
+                content.level += 1
+                content.nest()

tesorotools/render/content/table.py

@@ -0,0 +1,283 @@
+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
+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
+from docx.table import _Cell as TableCell
+from yaml import MappingNode
+
+from tesorotools.utils.config import read_config
+from tesorotools.utils.globals import EXAMPLES
+from tesorotools.utils.template import TemplateLoader
+
+RENDER_CONFIG: dict[str, Any] = read_config(EXAMPLES / "plots.yaml")["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: Table):
+    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: Table, 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: Table, horizontal: bool
+):
+    start_row: int = 2 if horizontal else 1
+
+    index_names: pd.Index = (
+        index if horizontal 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: Table):
+    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: Table,
+    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]
+        shade: str | None = shade_table.values[x, y]
+        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: Table):
+    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,
+) -> Table:
+
+    horizontal: bool = isinstance(table.columns, pd.MultiIndex)
+    table_docx: Table = 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)
+    return document
+
+
+class Table:
+    """A rendered table in the document"""
+
+    def __init__(
+        self,
+        data_file: Path | None,
+        color_file: Path | None,
+        shade_file: Path | 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")
+        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)
+
+    def render(self, document: Document) -> Document:
+        document = render_table(
+            self._data,
+            self._color,
+            self._shade,
+            document,
+            block_sep=self._block_sep,
+        )
+        return document

tesorotools/render/headline.py

@@ -0,0 +1,40 @@
+from typing import Any, Self
+
+from docx.document import Document
+
+
+class HeadLine:
+    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_dict(cls, headline_cfg: dict[str, Any]) -> Self:
+        title: str | None = headline_cfg.get("title", None)
+        comment: str | None = headline_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
+
+    @title.setter
+    def title(self, title) -> None:
+        self._title = title
+
+    @property
+    def comment(self) -> str:
+        return self._comment

tesorotools/render/introduction.py

@@ -0,0 +1,49 @@
+from datetime import date, datetime, time
+from typing import Any, Self
+
+from babel.dates import format_datetime
+from docx.document import Document
+
+
+class Introduction:
+    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_dict(cls, introduction_cfg: dict[str, Any]) -> Self:
+        # parse date
+        date_cfg: str | date | None = introduction_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 = introduction_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/report.py

@@ -0,0 +1,29 @@
+from typing import Any, Self
+
+from docx.document import Document
+from yaml import Loader, MappingNode
+
+from tesorotools.render.content.content import Content
+
+
+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)
+            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,12 @@
+from pathlib import Path
+
+DEBUG: Path = Path("debug")
+CONFIG: Path = Path("config")
+EXAMPLES: Path = Path("examples")
+
+ASSETS: Path = Path("assets")
+FONTS: Path = ASSETS / "fonts"
+
+STYLE_SHEET: Path = Path("tesoro.mplstyle")
+
+PLOT_CONFIG_FILE: Path = EXAMPLES / "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