tesorotools-python 0.0.6__py2.py3-none-any.whl → 0.0.7__py2.py3-none-any.whl

{tesorotools_python-0.0.6.dist-info → tesorotools_python-0.0.7.dist-info}/METADATA

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

tesorotools_python-0.0.7.dist-info/RECORD

@@ -0,0 +1,3 @@
+tesorotools_python-0.0.7.dist-info/METADATA,sha256=3rD3qrljFgGk0QKP5gHOwvI-dx3jL5w8vtjQwnSmH1o,323
+tesorotools_python-0.0.7.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+tesorotools_python-0.0.7.dist-info/RECORD,,

tesorotools/artists/__init__.py

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

tesorotools/artists/barh_plot.py

@@ -1,310 +0,0 @@
-from enum import Enum
-from pathlib import Path
-from typing import Any
-
-import matplotlib.pyplot as plt
-import pandas as pd
-from matplotlib.container import BarContainer
-from matplotlib.ticker import FuncFormatter
-
-from tesorotools.offsets.offsets import Difference, FloatingOffset, Stat
-from tesorotools.offsets.outliers import flag_outliers
-from tesorotools.utils.globals import DEBUG
-from tesorotools.utils.matplotlib import (
-    PLOT_CONFIG,
-    format_annotation,
-    load_fonts,
-)
-
-BARH_CONFIG: dict[str, Any] = PLOT_CONFIG["barh"]
-AX_CONFIG: dict[str, Any] = PLOT_CONFIG["ax"]
-FIG_CONFIG: dict[str, Any] = PLOT_CONFIG["figure"]
-
-load_fonts()
-
-
-class Column(Enum):
-    VALUE = "value"
-    AXIS = "axis"
-    DEVIATION = "deviation"
-    COLOR = "color"
-    ALPHA = "alpha"
-
-
-def _style_spines(
-    ax: plt.Axes,
-    decimals: int,
-    units: str,
-    *,
-    color: str,
-    linewidth: str,
-):
-    ax.grid(visible=True, axis="x")
-    for spine in ax.spines.values():
-        spine.set_color(color)
-        spine.set_linewidth(linewidth)
-    ax.xaxis.set_major_formatter(
-        FuncFormatter(lambda x, _: format_annotation(x, decimals, units))
-    )
-    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, **baseline_config):
-    color: str = baseline_config["color"]
-    left_lim, right_lim = ax.get_xlim()
-    ax.set_xlim(left=min(0, left_lim), right=max(0, right_lim))
-    left_lim, right_lim = ax.get_xlim()
-    if left_lim == 0:
-        ax.spines["left"].set_edgecolor(color)
-    elif right_lim == 0:
-        ax.spines["right"].set_edgecolor(color)
-    else:
-        ax.axvline(x=0, **baseline_config)
-
-
-def _collect_series(
-    blocks: dict[str, Any] | None, series: dict[str, str] | None
-) -> dict[str, str]:
-    if series is None and blocks is None:
-        raise ValueError("blocks and series cannot be both missing")
-    if series is None and blocks is not None:
-        return _collect_block_series(blocks)
-    else:
-        return series
-
-
-def _collect_block_series(blocks: dict[str, Any]) -> dict[str, str]:
-    series = {}
-    for _, block_cfg in blocks.items():
-        series = series | block_cfg["series"]
-    return series
-
-
-def _infer_colors(
-    value_series: pd.Series, blocks: dict[str, Any] | None
-) -> pd.Series:
-    color_series: pd.Series = pd.Series(
-        index=value_series.index, name=Column.COLOR.value, dtype=str
-    )
-    if blocks is not None:
-        for idx, block_cfg in enumerate(blocks.values()):
-            block_series: dict[str, str] = block_cfg["series"]
-            color_series.loc[block_series.keys()] = f"C{idx}"
-    else:
-        color_series[value_series >= 0] = "C0"
-        color_series[value_series < 0] = "C1"
-    return color_series
-
-
-def _highlight_series(
-    alias: dict[str, str], value_series: pd.Series
-) -> pd.Series:
-    alpha_series: pd.Series = pd.Series(
-        index=value_series.index, name=Column.ALPHA.value
-    )
-    alpha_series.loc[:] = 1
-    high_series = [k for k, v in alias.items() if v.endswith("*")]
-    alpha_series.loc[high_series] = BARH_CONFIG["highlight_factor"]
-    return alpha_series
-
-
-def _format_yaxis(
-    alias: dict[str, str],
-    axis_format: dict[str, Any],
-    value_series: pd.Series,
-    axis_series: pd.Series | None,
-) -> pd.Series:
-    # format y axis ticker labels
-    renamer = {_: label.replace("*", "") for _, label in alias.items()}
-    value_series = value_series.rename(renamer)
-    if axis_format is not None:
-        decimals: int = axis_format["decimals"]
-        units: str = axis_format["units"]
-        axis_series: pd.Series = axis_series.rename(renamer).apply(
-            lambda x: format_annotation(x, decimals, units)
-        )
-        value_series = value_series.rename(
-            lambda x: f"{x} ({axis_series.loc[x]})"
-        )
-    return value_series
-
-
-def _annotate(
-    fig: plt.Figure,
-    ax: plt.Axes,
-    bar_container: BarContainer,
-    *,
-    decimals: int,
-    units: str,
-):
-    # annotate
-    labels = ax.bar_label(
-        container=bar_container,
-        fmt=lambda x: format_annotation(x, decimals, units),
-        padding=BARH_CONFIG["padding"],
-    )
-
-    # rescale
-    fig.canvas.draw_idle()
-    for label in labels:
-        bbox = label.get_window_extent()
-        bbox_data = bbox.transformed(ax.transData.inverted())
-        ax.update_datalim(bbox_data.corners())
-        ax.autoscale_view()
-
-
-def _plot_barh_chart(
-    out_file: Path,
-    standard_dict: dict[Column, pd.Series | None],
-    alias: dict[str, str],
-    sorted: bool,
-    format: dict,
-    annot_format: dict,
-    axis_format: dict | None = None,
-    blocks: dict | None = None,
-    **kwargs,
-):
-    # infer colors
-    value_series: pd.Series = standard_dict[Column.VALUE]
-    color_series: pd.Series = _infer_colors(value_series, blocks)
-    alpha_series: pd.Series = _highlight_series(alias, value_series)
-
-    # format y axis ticker labels
-    axis_series = standard_dict[Column.AXIS]
-    value_series = _format_yaxis(alias, axis_format, value_series, axis_series)
-    color_series.index = value_series.index
-    alpha_series.index = value_series.index
-
-    data: pd.DataFrame = pd.concat(
-        [value_series, color_series, alpha_series], axis=1
-    )
-
-    # sort if required
-    if sorted:
-        data = data.sort_values(by=Column.VALUE.value)
-
-    # plot
-    fig = plt.figure(**FIG_CONFIG)
-    ax = fig.add_subplot()
-
-    bar_container: BarContainer = ax.barh(
-        y=data.index,
-        width=data[Column.VALUE.value],
-        color=data[Column.COLOR.value],
-    )
-    for bar, alpha in zip(bar_container, data[Column.ALPHA.value]):
-        bar.set_alpha(alpha)
-
-    _annotate(fig, ax, bar_container, **annot_format)
-    _style_spines(ax, **format, **AX_CONFIG["spines"])
-    _style_baseline(ax, **AX_CONFIG["baseline"])
-
-    fig.savefig(out_file)
-
-
-def _normalize_from_flash(
-    flash: pd.DataFrame,
-    axis: bool,
-    *,
-    date: str | pd.Timestamp | None,
-    offset: str,
-    difference: str,
-    deviations: bool,
-    units_bar: str,
-    units_axis: str,
-) -> dict[Column, pd.Series | None]:
-
-    # format parameters
-    date: pd.Timestamp = (
-        flash.index.get_level_values(level=0).max()
-        if date is None
-        else pd.to_datetime(date)
-    )
-    offset: FloatingOffset = FloatingOffset(offset)
-    difference: Difference = Difference(difference)
-
-    # value column
-    values_series: pd.Series = flash.loc[
-        (date, offset.value, difference.value, Stat.VALUE.value),
-        :,
-    ].copy()
-    values_series.name = Column.VALUE.value
-    values_series = (
-        values_series * 100 if difference is Difference.REL else values_series
-    )
-    values_series = (
-        values_series * 100
-        if (difference is Difference.ABS and units_bar == "p.b.")
-        else values_series
-    )
-
-    # axis column
-    if axis:
-        axis_series: pd.Series = flash.loc[
-            (
-                date,
-                FloatingOffset.NO.value,
-                Difference.NO.value,
-                Stat.VALUE.value,
-            ),
-            :,
-        ].copy()
-        axis_series = (
-            axis_series * 100
-            if (difference is Difference.ABS and units_axis == "p.b.")
-            else axis_series
-        )
-
-        axis_series.name = Column.AXIS.value
-    else:
-        axis_series = None
-
-    # deviations column
-    if deviations:
-        deviations_df: pd.DataFrame = flash.loc[
-            (
-                date,
-                offset.value,
-                difference.value,
-                [Stat.VALUE.value, Stat.ROLL_AVG.value, Stat.ROLL_STD._value_],
-            ),
-            :,
-        ].T.copy()
-        deviations_df.columns = deviations_df.columns.get_level_values(level=-1)
-        deviations_df.columns.name = None
-        deviations_series: pd.Series = flag_outliers(deviations_df)
-        deviations_series.name = Column.DEVIATION.value
-    else:
-        deviations_series = None
-
-    return {
-        Column.VALUE: values_series,
-        Column.AXIS: axis_series,
-        Column.DEVIATION: deviations_series,
-    }
-
-
-def plot_barh_charts_from_flash(
-    flash: pd.DataFrame, config_dicts: dict[str, dict]
-):
-    for name, config in config_dicts.items():
-        blocks: dict[str, Any] = config.get("blocks", None)
-        series: dict[str, str] | None = config.get("series", None)
-        alias = _collect_series(blocks, series)
-        trimmed_flash: pd.DataFrame = flash.loc[:, alias.keys()]
-        flash_config: dict[str, Any] = config["flash"]
-        axis_format: dict[str, Any] = config.get("axis_format", None)
-        axis = axis_format is not None
-        standard_dict: dict[Column, pd.Series | None] = _normalize_from_flash(
-            trimmed_flash,
-            axis,
-            **flash_config,
-            units_bar=config["format"]["units"],
-            units_axis=config.get("axis_format", {"units": ""})["units"],
-        )
-        out_file = Path(DEBUG / "barh" / f"{name}.png")
-        _plot_barh_chart(out_file, standard_dict, alias, **config)

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)

tesorotools/artists/table.py

@@ -1,199 +0,0 @@
-from math import floor
-from typing import Any
-
-import pandas as pd
-
-from tesorotools.dependencies.resolution import collect_series
-from tesorotools.offsets.outliers import flag_outliers
-from tesorotools.utils.globals import DEBUG
-from tesorotools.utils.matplotlib import format_annotation, is_zero
-
-# this file is by far the worst and most spaghettified, must be rewritten
-
-# to global config
-GOOD: str = "00c800"
-BAD: str = "c80000"
-THRESHOLD: float = 1
-SHADE_LEVELS = 2
-
-
-def _shade_intensity(
-    ratio: float, shade_levels: int = 2, continuous: bool = False
-) -> str:
-    # intensity may vary from 150 (highest) to 255 (lowest), a grand difference of 105
-    # there are SHADE_LEVELS levels, so increments will be of 105/SHADE_LEVELS
-    corrected_ratio: float = min(ratio, shade_levels)
-    corrected_ratio: float = (
-        floor(corrected_ratio) if not continuous else corrected_ratio
-    )
-    increment: float = (corrected_ratio - 1) * (105 / shade_levels)
-    intensity: float = 255 - increment
-    intensity_hex: str = f"{int(intensity):x}"
-    return intensity_hex
-
-
-def _generate_column(
-    column_data: pd.Series,
-    column_cfg: dict[str, Any],
-    outliers_flags: pd.Series | None = None,
-):
-    # TODO: factor out
-    # data
-    if column_cfg["show_units_in_title"]:
-        column_data.name = f"{column_cfg["name"]} ({column_cfg["unit"]})"
-    else:
-        column_data.name = column_cfg["name"]
-    column_cfg["formatted_name"] = column_data.name
-
-    unit = (
-        column_cfg["unit"]
-        if column_cfg["show_units_in_cell"] and column_cfg["unit"] is not None
-        else ""
-    )
-    scaled_data: pd.Series = column_data * column_cfg["scale"]
-    formatted_data = scaled_data.apply(
-        lambda x: format_annotation(
-            x, decimals=column_cfg["decimals"], units=unit
-        )
-    )
-    zeros: pd.Series = scaled_data.apply(
-        lambda x: is_zero(x, decimals=column_cfg["decimals"])
-    )
-    positives: pd.Series = scaled_data > 0
-    negatives: pd.Series = scaled_data < 0
-
-    # colors
-    colors_cfg: bool = column_cfg["colors"]
-    color_data: pd.Series = pd.Series(
-        index=formatted_data.index, name=column_data.name, dtype=str
-    )
-    if colors_cfg:
-        positive_good: bool = column_cfg["positive_good"]
-        color_data[positives] = GOOD if positive_good else BAD
-        color_data.loc[negatives] = BAD if positive_good else GOOD
-        color_data.loc[zeros.values] = pd.NA
-
-    # shades
-    shade_data: pd.Series = pd.Series(
-        index=formatted_data.index, name=column_data.name, dtype=str
-    )
-    if outliers_flags is not None:
-        thresholds: pd.Series = abs(outliers_flags / THRESHOLD)
-        intensities: pd.Series = thresholds.apply(
-            lambda x: _shade_intensity(x, SHADE_LEVELS)
-        )
-        shade_data[(thresholds >= 1) & (outliers_flags > 0)] = intensities[
-            (thresholds >= 1) & (outliers_flags > 0)
-        ].apply(lambda x: f"00{x}00" if positive_good else f"{x}0000")
-        shade_data[(thresholds >= 1) & (outliers_flags < 0)] = intensities[
-            (thresholds >= 1) & (outliers_flags < 0)
-        ].apply(lambda x: f"{x}0000" if positive_good else f"00{x}00")
-
-    return formatted_data, color_data, shade_data
-
-
-def _generate_block(block_data: pd.DataFrame, block_cfg: dict[str, Any]):
-    columns: dict[str, Any] = block_cfg["columns"]
-    formatted_columns: list[pd.Series] = []
-    color_columns: list[pd.Series] = []
-    shade_columns: list[pd.Series] = []
-    sort_idx: pd.Index | None = None
-    for column_name, column_cfg in columns.items():
-        last_date: pd.Timestamp = block_data.index.get_level_values(
-            level=0
-        ).max()
-        block_data = block_data.rename(columns=block_cfg["series"])
-        offset: str = column_cfg["offset"]
-        difference: str = column_cfg["difference"]
-        stat: str = column_cfg["stat"]
-        outliers: bool = column_cfg["outliers"]
-
-        stat_data = block_data.loc[
-            (last_date, offset, difference, slice(None)), :
-        ]
-        stat_data.index = stat_data.index.get_level_values(level=-1)
-
-        outliers_flags: pd.Series | None = None
-        if outliers:
-            outliers_flags = flag_outliers(stat_data.T)
-
-        column_data: pd.Series = stat_data.loc[stat, :]
-        # sort capability
-        sort: str = block_cfg.get("sort", None)
-        if sort is not None and column_name == sort:
-            column_data: pd.Series = column_data.sort_values(ascending=False)
-            sort_idx = column_data.index
-        formatted_column, color_column, shade_column = _generate_column(
-            column_data, column_cfg, outliers_flags
-        )
-        formatted_columns.append(formatted_column)
-        color_columns.append(color_column)
-        shade_columns.append(shade_column)
-
-    if sort_idx is not None:
-        formatted_columns = [s.reindex(sort_idx) for s in formatted_columns]
-        color_columns = [s.reindex(sort_idx) for s in color_columns]
-        shade_columns = [s.reindex(sort_idx) for s in shade_columns]
-
-    formatted_block: pd.DataFrame = pd.concat(formatted_columns, axis=1)
-    color_block: pd.DataFrame = pd.concat(color_columns, axis=1)
-    shade_block: pd.DataFrame = pd.concat(shade_columns, axis=1)
-
-    formatted_block.columns.name = block_cfg["title"]
-    color_block.columns.name = block_cfg["title"]
-    shade_block.columns.name = block_cfg["title"]
-    return formatted_block, color_block, shade_block
-
-
-def generate_table(table_data: pd.DataFrame, table_cfg: dict[str, Any]):
-    blocks: dict[str, dict] = table_cfg["blocks"]
-    formatted_blocks: list[pd.DataFrame] = []
-    color_blocks: list[pd.DataFrame] = []
-    shade_blocks: list[pd.DataFrame] = []
-    axis = 0 if table_cfg["axis"] == "vertical" else 1
-    # sorting capabilities
-    for block_name, block_cfg in blocks.items():
-        series_dict: dict[str, str] = block_cfg["series"]
-        block_data: pd.DataFrame = table_data.loc[:, series_dict.keys()]
-        formatted_block, color_block, shade_block = _generate_block(
-            block_data, block_cfg
-        )
-        formatted_blocks.append(formatted_block)
-        color_blocks.append(color_block)
-        shade_blocks.append(shade_block)
-    formatted_table = pd.concat(
-        formatted_blocks,
-        axis=axis,
-        keys=[
-            formatted_block.columns.name for formatted_block in formatted_blocks
-        ],
-    )
-    color_table = pd.concat(
-        color_blocks,
-        axis=axis,
-        keys=[
-            formatted_block.columns.name for formatted_block in formatted_blocks
-        ],
-    )
-    shade_table = pd.concat(
-        shade_blocks,
-        axis=axis,
-        keys=[
-            formatted_block.columns.name for formatted_block in formatted_blocks
-        ],
-    )
-    return formatted_table, color_table, shade_table
-
-
-def generate_tables_from_flash(
-    flash: pd.DataFrame, config_dicts: dict[str, dict]
-):
-    for table_name, table_cfg in config_dicts.items():
-        series: list[str] = list(collect_series(table_cfg))
-        table_data: pd.DataFrame = flash.loc[:, series]
-        formatted_table, color_table, shade_table = generate_table(
-            table_data, table_cfg
-        )
-        formatted_table.to_feather(DEBUG / "table" / f"{table_name}.feather")
-        color_table.to_feather(DEBUG / "table" / f"{table_name}_color.feather")
-        shade_table.to_feather(DEBUG / "table" / f"{table_name}_shade.feather")