from __future__ import annotations from collections import OrderedDict from enum import Enum from typing import Any import backtrader as bt from bokeh.layouts import column from bokeh.models.css import InlineStyleSheet from bokeh.models.layouts import LayoutDOM from bokeh.models.sources import ColumnDataSource from bokeh.models.widgets.markups import Div from bokeh.models.widgets.tables import DataTable, HTMLTemplateFormatter, TableColumn from ..schemes.scheme import Scheme from .analyzer_visual import VALUE_PRECISION from .params import get_params_str _ROW_HEIGHT: int = 25 # matches Bokeh DataTable default, used to sync row_height= and height= _MAX_TABLE_HEIGHT: int = 400 _PLOT_METHOD = "get_analysis_plot" _TABLE_METHOD = "get_analysis_table_visual" class ColumnDataType(Enum): DATETIME = 1 FLOAT = 2 INT = 3 PERCENTAGE = 4 STRING = 5 def _get_column_formatter(ctype: ColumnDataType, scheme: Scheme) -> Any: c: str = scheme.text_color if ctype is ColumnDataType.FLOAT: return HTMLTemplateFormatter( template=( f'' "<%= (value == null || isNaN(parseFloat(String(value)))) ? " f"'-' : parseFloat(String(value)).toFixed({VALUE_PRECISION})" ".replace(/\\.?0+$/, '') %>" "" ) ) if ctype is ColumnDataType.INT: return HTMLTemplateFormatter( template=( f'' "<%= (value == null || isNaN(parseFloat(String(value)))) ? " "'-' : Math.round(parseFloat(String(value))).toLocaleString() %>" "" ) ) if ctype is ColumnDataType.DATETIME: return HTMLTemplateFormatter(template=f'<%= value %>') if ctype is ColumnDataType.STRING: return HTMLTemplateFormatter( template=f"<%= value !== null && value !== undefined ? value : '-' %>" ) if ctype is ColumnDataType.PERCENTAGE: return HTMLTemplateFormatter( template=( f'' "<%= (value == null || isNaN(parseFloat(String(value)))) ? " "'-' : (parseFloat(String(value)) * 100).toFixed(3)" ".replace(/\\.?0+$/, '') + '%' %>" "" ) ) raise ValueError(f'Unsupported ColumnDataType: "{ctype}"') def build_table( table_columns: list[list[Any]], scheme: Scheme, stylesheet: InlineStyleSheet, ) -> DataTable: cds: ColumnDataSource = ColumnDataSource() columns: list[TableColumn] = [] for i, c in enumerate(table_columns): col_name: str = f"col{i}" cds.add(c[2:], col_name) columns.append( TableColumn(field=col_name, title=c[0], formatter=_get_column_formatter(c[1], scheme)) ) n_data_rows: int = len(table_columns[0]) - 2 return DataTable( source=cds, columns=columns, index_position=None, row_height=_ROW_HEIGHT, height=min((n_data_rows + 1) * _ROW_HEIGHT, _MAX_TABLE_HEIGHT), max_height=_MAX_TABLE_HEIGHT, width=0, sizing_mode="stretch_width", fit_columns=True, stylesheets=[stylesheet], ) class ParamTableBuilder: def __init__(self, stylesheet: InlineStyleSheet) -> None: self._stylesheet = stylesheet def build(self, data: dict[str, Any]) -> DataTable: table: list[list[Any]] = [["Name"], ["Value"]] cds: ColumnDataSource = ColumnDataSource() columns: list[TableColumn] = [] for n, v in data.items(): table[0].append(n) table[1].append(v) for i, c in enumerate(table): col_name: str = f"col{i}" cds.add(c[1:], col_name) columns.append(TableColumn(field=col_name, title=c[0])) return DataTable( source=cds, columns=columns, index_position=None, row_height=_ROW_HEIGHT, height=min(len(table[0]) * _ROW_HEIGHT, _MAX_TABLE_HEIGHT), sizing_mode="stretch_width", fit_columns=True, stylesheets=[self._stylesheet], ) class LegacyTableBuilder: """Legacy table-only builder, kept for backward compatibility.""" def __init__(self, scheme: Scheme, stylesheet: InlineStyleSheet) -> None: self._scheme = scheme self._stylesheet = stylesheet @staticmethod def _build_columns_from_analysis(analyzer: Any) -> tuple[str, list[list[list[Any]]]]: table: list[list[Any]] = [["", ColumnDataType.STRING], ["Value", ColumnDataType.STRING]] def add_to_table(item: Any, baselabel: str = "") -> None: if isinstance(item, dict): for ak, av in item.items(): label: str = f"{baselabel} - {ak}" if baselabel else ak if isinstance(av, (dict, bt.AutoOrderedDict, OrderedDict)): add_to_table(av, label) else: table[0].append(label) table[1].append(av) add_to_table(analyzer.get_analysis()) return analyzer.__class__.__name__, [table] def build_tables(self, analyzer: Any) -> tuple[Div | None, list[DataTable] | None]: if hasattr(analyzer, "get_analysis_table"): title, table_columns_list = analyzer.get_analysis_table() else: title, table_columns_list = LegacyTableBuilder._build_columns_from_analysis(analyzer) if len(table_columns_list[0][0]) == 2: return None, None param_str: str = get_params_str(analyzer.params) if param_str: title += f" ({param_str})" elems: list[DataTable] = [ build_table(tc, self._scheme, self._stylesheet) for tc in table_columns_list ] title_div: Div = Div( text=title, css_classes=["table-title"], stylesheets=[self._stylesheet] ) return title_div, elems class AnalysisVisualBuilder: def __init__(self, scheme: Scheme, stylesheet: InlineStyleSheet) -> None: self._scheme = scheme self._stylesheet = stylesheet def build_plot(self, analyzer: Any) -> LayoutDOM | None: if hasattr(analyzer, _PLOT_METHOD): return getattr(analyzer, _PLOT_METHOD)(self._scheme, self._stylesheet) return None def build_table_layout(self, analyzer: Any) -> LayoutDOM | None: if hasattr(analyzer, _TABLE_METHOD): return getattr(analyzer, _TABLE_METHOD)(self._scheme, self._stylesheet) return None # self._build_legacy_table(analyzer) def _build_legacy_table(self, analyzer: Any) -> LayoutDOM | None: if hasattr(analyzer, "get_analysis_visual"): return analyzer.get_analysis_visual(self._scheme, self._stylesheet) if hasattr(analyzer, "get_analysis_table"): title, table_columns_list = analyzer.get_analysis_table() else: title, table_columns_list = LegacyTableBuilder._build_columns_from_analysis(analyzer) if len(table_columns_list[0][0]) == 2: return None param_str: str = get_params_str(analyzer.params) if param_str: title += f" ({param_str})" elems: list[DataTable] = [ build_table(tc, self._scheme, self._stylesheet) for tc in table_columns_list ] title_div: Div = Div( text=title, css_classes=["table-title"], stylesheets=[self._stylesheet] ) return column(children=[title_div, *elems], sizing_mode="stretch_width") def build_visual(self, analyzer: Any) -> LayoutDOM | None: plot: LayoutDOM | None = self.build_plot(analyzer) table: LayoutDOM | None = self.build_table_layout(analyzer) if plot is None and table is None: return None parts: list[LayoutDOM] = [p for p in [plot, table] if p is not None] if len(parts) == 1: return parts[0] return column(children=parts, sizing_mode="stretch_width") class ObserverVisualBuilder: """Builds Bokeh visual panels for observer objects. Mirrors AnalysisVisualBuilder but calls observer-specific methods (get_observer_plot / get_observer_table_visual). """ _OBS_PLOT_METHOD: str = "get_observer_plot" _OBS_TABLE_METHOD: str = "get_observer_table_visual" def __init__(self, scheme: Scheme, stylesheet: InlineStyleSheet) -> None: self._scheme = scheme self._stylesheet = stylesheet def build_plot(self, observer: Any) -> LayoutDOM | None: if hasattr(observer, self._OBS_PLOT_METHOD): return getattr(observer, self._OBS_PLOT_METHOD)(self._scheme, self._stylesheet) return None def build_table_layout(self, observer: Any) -> LayoutDOM | None: if hasattr(observer, self._OBS_TABLE_METHOD): return getattr(observer, self._OBS_TABLE_METHOD)(self._scheme, self._stylesheet) return None def build_visual(self, observer: Any) -> LayoutDOM | None: plot: LayoutDOM | None = self.build_plot(observer) table: LayoutDOM | None = self.build_table_layout(observer) if plot is None and table is None: return None parts: list[LayoutDOM] = [p for p in [plot, table] if p is not None] if len(parts) == 1: return parts[0] return column(children=parts, sizing_mode="stretch_width")