deepboard 0.2.0__py3-none-any.whl

deepboard/gui/pages/main_page/right_panel/template.py

@@ -0,0 +1,151 @@
+from fasthtml.common import *
+from datetime import datetime
+from .scalars import ScalarTab, scalar_enable
+from .images import ImageTab, images_enable
+from .fragments import FragmentTab, fragment_enable
+from .config import ConfigView
+from .hparams import HParamsView
+from .run_info import InfoView
+
+def reset_scalar_session(session):
+    session["scalars"] = dict(
+        hidden_lines=[],
+        smoother_value=1,
+        chart_type='step'
+    )
+
+def RightPanelContent(session, run_id: int, active_tab: str):
+    from __main__ import rTable
+    scalar_is_available = scalar_enable(run_id)
+    images_is_available = images_enable(run_id, type="IMAGES")
+    plot_is_available = images_enable(run_id, type="PLOT")
+    text_is_available = fragment_enable(run_id, type="RAW")
+    fragment_is_available = fragment_enable(run_id, type="HTML")
+
+
+    # Verify that the active tab requested is availalable
+    if active_tab == 'scalars' and not scalar_is_available:
+        active_tab = "images"
+    if active_tab == "images" and not images_is_available:
+        active_tab = "figures"
+    if active_tab == "figures" and not plot_is_available:
+        active_tab = "text"
+    if active_tab == "text" and not text_is_available:
+        active_tab = "fragments"
+    if active_tab == "fragments" and not fragment_is_available:
+        active_tab = "config"
+
+    if active_tab == 'scalars':
+        tab_content = ScalarTab(session, run_id)
+    elif active_tab == 'images':
+        tab_content = ImageTab(session, run_id, type="IMAGE")
+    elif active_tab == 'figures':
+        tab_content = ImageTab(session, run_id, type="PLOT")
+    elif active_tab == 'text':
+        tab_content = FragmentTab(session, run_id, type="RAW")
+    elif active_tab == 'fragments':
+        tab_content = FragmentTab(session, run_id, type="HTML")
+    elif active_tab == 'config':
+        tab_content = ConfigView(run_id)
+    elif active_tab == 'hparams':
+        tab_content = HParamsView(run_id)
+    elif active_tab == 'run_info':
+        tab_content = InfoView(run_id)
+    else:
+        tab_content = Div(
+            P("Invalid tab selected.", cls="error-message")
+        )
+    run_name = "DEBUG" if run_id == -1 else run_id
+    tabs = []
+
+    # If the runID does not have any scalars logged, we do not show the scalars tab
+    if scalar_is_available:
+        tabs.append(
+            Div('Scalars', cls='tab active' if active_tab == 'scalars' else 'tab',
+                hx_get=f'/fillpanel?run_id={run_id}&tab=scalars', hx_target='#right-panel-content',
+                hx_swap='outerHTML')
+        )
+
+    if images_is_available:
+        tabs.append(
+            Div('Images', cls='tab active' if active_tab == 'images' else 'tab',
+                hx_get=f'/fillpanel?run_id={run_id}&tab=images', hx_target='#right-panel-content',
+                hx_swap='outerHTML')
+        )
+
+    if plot_is_available:
+        tabs.append(
+            Div('Figures', cls='tab active' if active_tab == 'figures' else 'tab',
+                hx_get=f'/fillpanel?run_id={run_id}&tab=figures', hx_target='#right-panel-content',
+                hx_swap='outerHTML')
+        )
+
+    if text_is_available:
+        tabs.append(
+            Div('Text', cls='tab active' if active_tab == 'text' else 'tab',
+                hx_get=f'/fillpanel?run_id={run_id}&tab=text', hx_target='#right-panel-content',
+                hx_swap='outerHTML')
+        )
+
+    if fragment_is_available:
+        tabs.append(
+            Div('Fragments', cls='tab active' if active_tab == 'fragments' else 'tab',
+                hx_get=f'/fillpanel?run_id={run_id}&tab=fragments', hx_target='#right-panel-content',
+                hx_swap='outerHTML')
+        )
+
+    tabs += [
+        Div('Config', cls='tab active' if active_tab == 'config' else 'tab',
+            hx_get=f'/fillpanel?run_id={run_id}&tab=config', hx_target='#right-panel-content', hx_swap='outerHTML'),
+        Div('HParams', cls='tab active' if active_tab == 'hparams' else 'tab',
+            hx_get=f'/fillpanel?run_id={run_id}&tab=hparams', hx_target='#right-panel-content', hx_swap='outerHTML'),
+        Div('Info', cls='tab active' if active_tab == 'run_info' else 'tab',
+            hx_get=f'/fillpanel?run_id={run_id}&tab=run_info', hx_target='#right-panel-content',
+            hx_swap='outerHTML'),
+    ]
+    return Div(
+        H1(f"Run: {run_name}"),
+        Div(
+            *tabs,
+            cls='tab-menu'
+        ),
+        Div(
+            tab_content,
+            id='tab-content', cls='tab-content'
+        ),
+        cls="right-panel-content",
+        id="right-panel-content"
+    ),
+
+def OpenPanel(session, run_id: int, active_tab: str = 'scalars'):
+    return Div(
+        RightPanelContent(session, run_id, active_tab),
+        cls="open-right-panel"
+    )
+
+def RightPanel(session, closed: bool = False):
+    placeholder_text = [
+        P("⌘ / ctrl + click to compare runs", cls="right-panel-placeholder"),
+        P("'F' for fullscreen", cls="right-panel-placeholder")
+    ]
+    if "datagrid" in session and session["datagrid"].get("selected-rows") and len(session["datagrid"]["selected-rows"]) == 1:
+        run_id = session["datagrid"]["selected-rows"][0]
+    else:
+        run_id = None
+    return Div(
+        Button(
+            I(cls="fas fa-times"),
+            hx_get="/reset",
+            hx_target="#container",
+            hx_swap="outerHTML",
+            cls="close-button",
+        ) if run_id is not None else None,
+        Div(*placeholder_text) if run_id is None else OpenPanel(session, run_id),
+        id='right-panel',
+        cls="right-panel" if not closed else "right-panel-closed",
+        hx_swap_oob='true'
+    ),
+
+
+def fill_panel(session, run_id: int, tab: str):
+    return RightPanelContent(session, run_id, tab)

deepboard/gui/pages/main_page/routes.py

@@ -0,0 +1,25 @@
+from .handlers import click_row_handler
+from .datagrid import build_datagrid_endpoints
+from .right_panel import build_right_panel_routes
+from .main_page import MainPage
+from deepboard.gui.components import Modal
+
+def build_main_page_endpoints(rt):
+    rt("/click_row")(click_row_handler)
+    rt("/reset")(reset)
+    rt("/fullscreen")(fullscreen)
+    rt("/close_modal")(close_modal)
+    build_datagrid_endpoints(rt)
+    build_right_panel_routes(rt)
+
+def reset(session):
+    if "show_hidden" not in session:
+        session["show_hidden"] = False
+    session["datagrid"] = dict()
+    return MainPage(session, swap=True)
+
+def close_modal(session):
+    return Modal(active=False)
+
+def fullscreen(session, full: bool):
+    return MainPage(session, swap=True, fullscreen=full)

deepboard/gui/pages/not_found.py

@@ -0,0 +1,3 @@
+from fasthtml.common import *
+
+def _not_found(req, exc): return Title('Not found [404]'), Div(H1('We could not find that page :('), cls="center-center")

deepboard/gui/requirements.txt

@@ -0,0 +1,5 @@
+python-fasthtml
+fh-plotly
+plotly
+pandas
+markupsafe

deepboard/gui/utils.py

@@ -0,0 +1,267 @@
+from datetime import datetime, date, timedelta
+import sqlite3
+from typing import *
+import pandas as pd
+import plotly.graph_objects as go
+from decimal import Decimal, ROUND_HALF_UP
+import yaml
+import os
+import shutil
+import argparse
+import math
+
+def _adapt_date_iso(val):
+    """Adapt datetime.date to ISO 8601 date."""
+    return val.isoformat()
+
+
+def _adapt_datetime_iso(val):
+    """Adapt datetime.datetime to timezone-naive ISO 8601 date."""
+    return val.isoformat()
+
+def _convert_date(val):
+    """Convert ISO 8601 date to datetime.date object."""
+    return date.fromisoformat(val.decode())
+
+
+def _convert_datetime(val):
+    """Convert ISO 8601 datetime to datetime.datetime object."""
+    return datetime.fromisoformat(val.decode())
+
+def prepare_db():
+
+    sqlite3.register_adapter(datetime.date, _adapt_date_iso)
+    sqlite3.register_adapter(datetime, _adapt_datetime_iso)
+
+
+    sqlite3.register_converter("date", _convert_date)
+    sqlite3.register_converter("datetime", _convert_datetime)
+
+def make_df(socket, tag: Tuple[str, str]) -> Tuple[pd.DataFrame, List[int], List[int]]:
+    scalars = socket.read_scalar("/".join(tag))
+    steps = [scalar.step for scalar in scalars]
+    value = [scalar.value for scalar in scalars]
+    repetition = [scalar.run_rep for scalar in scalars]
+    walltime = [scalar.wall_time for scalar in scalars]
+    epochs = [scalar.epoch for scalar in scalars]
+    df = pd.DataFrame({
+        "step": steps,
+        "value": value,
+        "repetition": repetition,
+        "duration": walltime,
+        "epoch": epochs
+    })
+    available_rep = df["repetition"].unique()
+    available_epochs = df["epoch"].unique()
+    df = df.set_index(["step", "repetition"])
+    return df, available_rep, available_epochs
+
+def get_lines(socket, split, metric, key: Literal["step", "duration"]):
+    out = []
+    df, available_rep, available_epochs = make_df(socket, (split, metric))
+    for rep in available_rep:
+        rep_df = df.loc[(slice(None), rep), :]
+        out.append({
+            "index": rep_df.index.get_level_values("step") if key == "step" else rep_df["duration"],
+            "value": rep_df["value"],
+            "epoch": rep_df["epoch"].values if len(available_epochs) > 1 else None,
+        })
+    return out
+
+def ema(values, alpha):
+    """
+    Compute the Exponential Moving Average (EMA) of a list of values.
+
+    Parameters:
+    - values (list or numpy array): The data series.
+    - alpha (float): Smoothing factor (between 0 and 1).
+
+    Returns:
+    - list: EMA-smoothed values.
+    """
+    return values.ewm(alpha=alpha, adjust=False).mean()
+
+def make_fig(lines, type: str = "step", smoothness: float = 0., log_scale: bool = False):
+    from __main__ import CONFIG
+    fig = go.Figure()
+
+    for label, steps, values, color, epochs in lines:
+        # Smooth the values
+        if smoothness > 0:
+            values = ema(values, 1.01 - smoothness / 100)
+        if epochs is not None:
+            additional_setup = dict(hovertext=values, customdata=[[e, label] for e in epochs],
+                                    hovertemplate="%{customdata[1]} : %{y:.4f} | Epoch: %{customdata[0]}<extra></extra>")
+        else:
+            additional_setup = dict(hovertext=values, customdata=[[label] for _ in values],
+                                    hovertemplate="%{customdata[0]} : %{y:.4f}<extra></extra>")
+
+        if type == "time":
+            steps = [datetime(1970, 1, 1) + timedelta(seconds=s) for s in steps]
+        fig.add_trace(go.Scatter(
+            x=steps,
+            y=values,
+            mode='lines',
+            name=label,
+            line=dict(color=color),
+            **additional_setup
+        ))
+        if log_scale:
+            fig.update_yaxes(type="log")
+
+    if type == "step":
+        fig.update_layout(
+            CONFIG.PLOTLY_THEME,
+            xaxis_title="Step",
+            yaxis_title="Value",
+            hovermode="x unified",
+            showlegend=False,
+            autosize=True,
+            height=None,  # Let CSS control it
+            width=None,  # Let CSS control it
+            margin=dict(l=0, r=0, t=15, b=0)
+        )
+    elif type == "time":
+        fig.update_layout(
+            CONFIG.PLOTLY_THEME,
+            xaxis_title="Duration",
+            yaxis_title="Value",
+            hovermode="x unified",
+            showlegend=False,
+            xaxis_tickformat="%H:%M:%S",  # format the ticks like 01:23:45
+            autosize=True,
+            height=None,  # Let CSS control it
+            width=None,  # Let CSS control it
+            margin=dict(l=0, r=0, t=15, b=0)
+        )
+    else:
+        raise ValueError(f"Unknown plotting type: {type}")
+    return fig
+
+
+def smart_round(val, decimals=4):
+    """
+    Round a float to the given number of decimal places. However, if the float already has less decimal, noting is done!
+    In addition, if the value is about to get rounded to zero, it is converted to scientific notation.
+    :param val: The value to round.
+    :param decimals: The maximum number of decimal places to round.
+    :return: The rounded value.
+    """
+    # If infinity or NaN, return as is
+    if isinstance(val, float) and (math.isinf(val) or math.isnan(val)):
+        return str(val)
+    val_dec = Decimal(str(val))
+    quantizer = Decimal('1').scaleb(-decimals)
+    rounded = val_dec.quantize(quantizer, rounding=ROUND_HALF_UP)
+    if rounded.is_zero() and not val_dec.is_zero():
+        return f"{val:.{decimals}e}"
+    return str(rounded.normalize())
+
+def initiate_files():
+    abs_path = os.path.abspath(os.path.dirname(__file__))
+    if not os.path.exists(os.path.expanduser('~/.config/deepboard')):
+        os.makedirs(os.path.expanduser('~/.config/deepboard'))
+
+    if not os.path.exists(os.path.expanduser('~/.config/deepboard/THEME.yml')):
+        shutil.copy(f"{abs_path}/THEME.yml", os.path.expanduser('~/.config/deepboard/THEME.yml'))
+
+    if not os.path.exists(os.path.expanduser('~/.config/deepboard/THEME.css')):
+        shutil.copy(f"{abs_path}/assets/theme.css", os.path.expanduser('~/.config/deepboard/THEME.css'))
+
+def get_table_path_from_cli(default: str = "results/result_table.db") -> str:
+    # Parse cli args
+    parser = argparse.ArgumentParser(description="DeepBoard WebUI")
+    # Positional
+    parser.add_argument(
+            "table_path",
+            nargs="?",  # Make it optional positionally
+            help="Path to the result table db file"
+        )
+
+    # Optional keyword argument --table_path
+    parser.add_argument(
+        "--table_path",
+        help="Path to the result table db file"
+    )
+    args = parser.parse_args()
+
+    # Resolve to either positional or optional
+    table_path = args.table_path or args.__dict__.get("table_path")
+
+    if table_path is None:
+        table_path = default
+
+    return table_path
+
+def verify_runids(session: dict, rTable):
+    """
+    Verify that the runIDs in the session are valid and exist in the result table. If not, remove them from the session.
+    :param session: The fastHTML session dictionary.
+    :param rTable: The result table object.
+    :return: Modify inplace so it returns nothing.
+    """
+    if "datagrid" in session and session["datagrid"].get("selected-rows"):
+        valid_run_ids = []
+        runs = set(rTable.runs)
+        for run_id in session["datagrid"]["selected-rows"]:
+            if run_id in runs:
+                valid_run_ids.append(run_id)
+
+        # Set it back
+        session["datagrid"]["selected-rows"] = valid_run_ids
+class Config:
+    COLORS = [
+        "#1f77b4",  # muted blue
+        "#ff7f0e",  # vivid orange
+        "#2ca02c",  # medium green
+        "#d62728",  # brick red
+        "#9467bd",  # muted purple
+        "#8c564b",  # brownish pink
+        "#e377c2",  # pink
+        "#7f7f7f",  # gray
+        "#bcbd22",  # lime yellow
+        "#17becf",  # cyan
+    ]
+    HIDDEN_COLOR = "#333333"  # gray for hidden lines
+
+    PLOTLY_THEME = dict(
+        plot_bgcolor='#111111',  # dark background for the plotting area
+        paper_bgcolor='#111111',  # dark background for the full figure
+        font=dict(color='white'),  # white text everywhere (axes, legend, etc.)
+        xaxis=dict(
+            gridcolor='#333333',  # subtle dark grid lines
+            zerolinecolor='#333333'
+        ),
+        yaxis=dict(
+            gridcolor='#333333',
+            zerolinecolor='#333333'
+        ),
+    )
+
+    MAX_DEC = 4 # Maximum number of decimals
+
+    @classmethod
+    def FromFile(cls, path: str):
+        self = cls()
+        if os.path.exists(path):
+            with open(path, 'r') as f:
+                data = yaml.load(f, Loader=yaml.FullLoader)
+            self._update_theme(data)
+        else:
+            print("NO theme found, using default theme")
+        return self
+
+    def _update_theme(self, data: dict):
+        for key, value in data.items():
+            if not isinstance(value, dict):
+                setattr(self, key, value)
+            else:
+                self._merge_dict(getattr(self, key), value)
+
+    def _merge_dict(self, d, u):
+        for k, v in u.items():
+            if isinstance(v, dict) and isinstance(d.get(k), dict):
+                self._merge_dict(d[k], v)
+            else:
+                d[k] = v
+        return d

deepboard/resultTable/__init__.py

@@ -0,0 +1,2 @@
+from .resultTable import ResultTable, NoCommitAction
+from .logwritter import LogWriter

deepboard/resultTable/cursor.py

@@ -0,0 +1,20 @@
+import sqlite3
+
+class Cursor:
+    def __init__(self, db_path: str, format_as_dict: bool = False):
+        self.db_path = db_path
+        self.format_as_dict = format_as_dict
+
+    def __enter__(self):
+        self._conn = sqlite3.connect(self.db_path)
+        if self.format_as_dict:
+            self._conn.row_factory = sqlite3.Row
+        self._cursor = self._conn.cursor()
+        return self._cursor
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Commits changes if no exception occurred, then closes the connection."""
+        if self._conn:
+            if exc_type is None:  # No exceptions, commit changes
+                self._conn.commit()
+            self._conn.close()