deepboard 0.2.0__py3-none-any.whl

deepboard/gui/pages/main_page/datagrid/routes.py

@@ -0,0 +1,112 @@
+from typing import *
+from fasthtml.common import *
+from .datagrid import DataGrid
+from .compare_button import CompareButton
+from ..main_page import MainPage
+
+def build_datagrid_endpoints(rt):
+    rt("/hide")(hide_column)
+    rt("/show")(show_column)
+    rt("/rename_col_datagrid")(get_rename_column)
+    rt("/rename_col", methods=["POST"])(post_rename_column)
+    rt("/sort")(sort)
+    rt("/reorder_columns", methods=["POST"])(reorder_columns)
+    rt("/shift_click_row")(shift_click_row) # Endpoint is called in the javascript file
+    rt("/hide_run")(hide_run)
+    rt("/show_run")(show_run)
+    rt("/show_hidden")(show_hidden)
+    rt("/hide_hidden")(hide_hidden)
+    rt("/compare_action")(compare_action)
+
+async def hide_column(session, col: str):
+    from __main__ import rTable
+    rTable.hide_column(col)
+
+    # Return the datagrid
+    return DataGrid(session)
+
+async def show_column(session, col: str, after: str):
+    from __main__ import rTable
+    cols = rTable.result_columns
+    if after not in cols:
+        print(f"[WARNING]: Did not find column: {after}")
+        return DataGrid(session)
+    pos = cols[after][0] + 1
+    print(f"Show column: {col} after {after} position {pos}")
+    rTable.show_column(col, pos)
+
+    # Return the datagrid
+    return DataGrid(session)
+
+async def get_rename_column(session, col: str):
+    from __main__ import rTable
+    if col not in rTable.result_columns:
+        print(f"[WARNING]: Did not find column: {col}")
+        return DataGrid(session)
+    return DataGrid(session, rename_col=col)
+
+async def post_rename_column(session, col_id: str, new_name: str):
+    from __main__ import rTable
+    if col_id not in rTable.result_columns:
+        print(f"[WARNING]: Did not find column: {col_id}")
+        return DataGrid(session)
+    rTable.set_column_alias({col_id: new_name})
+
+    # Return the datagrid
+    return DataGrid(session)
+
+async def sort(session, by: str, order: str):
+    if "datagrid" not in session:
+        session["datagrid"] = dict(
+            sort_by=None,
+            sort_order=None
+        )
+    session["datagrid"]["sort_by"] = by
+    session["datagrid"]["sort_order"] = order
+    return DataGrid(session)
+
+async def reorder_columns(session, order: str):
+    from __main__ import rTable
+    order = order.split(",")
+    prep_order = {col_id: i + 1 for i, col_id in enumerate(order)}
+    rTable.set_column_order(prep_order)
+    return DataGrid(session)
+
+async def shift_click_row(session, run_id: int):
+    if "datagrid" not in session:
+        session["datagrid"] = dict()
+
+    session["datagrid"]["multiselection"] = True
+    if "selected-rows" not in session["datagrid"]:
+        session["datagrid"]["selected-rows"] = []
+
+    if run_id in session["datagrid"]["selected-rows"]:
+        session["datagrid"]["selected-rows"].remove(run_id)
+    else:
+        session["datagrid"]["selected-rows"].append(run_id)
+
+    return DataGrid(session), CompareButton(session, swap=True)
+
+async def hide_run(session, run_id: int):
+    from __main__ import rTable
+    rTable.hide_run(run_id)
+    return DataGrid(session)
+
+async def show_run(session, run_id: int):
+    from __main__ import rTable
+    rTable.show_run(run_id)
+    return DataGrid(session)
+
+async def show_hidden(session):
+    session["show_hidden"] = True
+    return DataGrid(session)
+
+async def hide_hidden(session):
+    session["show_hidden"] = False
+    return DataGrid(session)
+
+def compare_action(session, run_ids: str):
+    if "show_hidden" not in session:
+        session["show_hidden"] = False
+    session["datagrid"] = dict()
+    return MainPage(session, swap=True), HttpHeader("HX-Blank-Redirect", f"/compare?run_ids={run_ids}")

deepboard/gui/pages/main_page/datagrid/row.py

@@ -0,0 +1,20 @@
+from typing import *
+from fasthtml.common import *
+from .utils import format_value
+def Row(data, run_id, selected: bool, hidden: bool, max_decimals: int, fullscreen: bool):
+    cls = "table-row"
+    if selected:
+        cls += " table-row-selected"
+
+    if hidden:
+        cls += " table-row-hidden"
+
+    return Tr(
+        *[Td(format_value(value, decimals=max_decimals)) for value in data],
+        hx_get=f"/click_row?run_id={run_id}&fullscreen={fullscreen}",  # HTMX will GET this URL
+        hx_trigger="click[!event.ctrlKey && !event.metaKey]",
+        hx_target="#experiment-table",  # Target DOM element to update
+        hx_swap="innerHTML",  # Optional: how to replace content
+        id=f"grid-row-{run_id}",
+        cls=cls,
+    )

deepboard/gui/pages/main_page/datagrid/sortable_column_js.py

@@ -0,0 +1,45 @@
+from fasthtml.common import *
+
+def SortableColumnsJs():
+    src = """
+        import { Sortable } from 'https://cdn.jsdelivr.net/npm/sortablejs/+esm';
+
+        document.addEventListener('DOMContentLoaded', function() {
+            initSortable();
+        });
+
+        function initSortable() {
+            const headerRow = document.getElementById('column-header-row');
+
+            if (!headerRow) return;
+
+            // Initialize SortableJS on the header row
+            new Sortable(headerRow, {
+                animation: 150,
+                ghostClass: 'sortable-ghost',
+                onEnd: function(evt) {
+                    // Get the new column order
+                    const headers = Array.from(headerRow.children);
+                    const columnOrder = headers.map(header => 
+                        header.getAttribute('data-col'));
+
+                    // Send the new order to the server using htmx as a POST request
+                    htmx.ajax('POST', '/reorder_columns', {
+                        target: '#experiment-table',
+                        swap: 'innerHTML',
+                        values: {
+                            order: columnOrder.join(',')
+                        }
+                    });
+                }
+            });
+        }
+
+        // Re-initialize Sortable after HTMX content swaps
+        document.body.addEventListener('htmx:afterSwap', function(evt) {
+            if (evt.detail.target.id === 'experiment-table') {
+                initSortable();
+            }
+        });
+        """
+    return Script(src, type='module')

deepboard/gui/pages/main_page/datagrid/utils.py

@@ -0,0 +1,9 @@
+from deepboard.gui.utils import smart_round
+from datetime import datetime
+
+def format_value(value, decimals: int = 4):
+    if isinstance(value, datetime):
+        return value.strftime('%Y-%m-%d %H:%M:%S')
+    if isinstance(value, float):
+        return smart_round(value, decimals)
+    return value

deepboard/gui/pages/main_page/handlers.py

@@ -0,0 +1,16 @@
+from typing import *
+from fasthtml.common import *
+from .datagrid import DataGrid, CompareButton
+from .right_panel import RightPanel, reset_scalar_session
+from .main_page import MainPage
+
+# Choose a row in the datagrid
+def click_row_handler(session, run_id: int, fullscreen: bool):
+    reset_scalar_session(session)
+    if "datagrid" not in session:
+        session["datagrid"] = dict()
+    session["datagrid"]["selected-rows"] = [run_id]
+    if fullscreen:
+        return MainPage(session, swap=True)
+    else:
+        return DataGrid(session), CompareButton(session, swap=True), RightPanel(session)

deepboard/gui/pages/main_page/main_page.py

@@ -0,0 +1,21 @@
+from typing import *
+from fasthtml.common import *
+from .datagrid import DataGrid, CompareButton
+from .right_panel import RightPanel
+
+def MainPage(session, swap: bool = False, fullscreen: bool = False):
+    return Div(
+        Div(
+            DataGrid(session, wrapincontainer=True, fullscreen=fullscreen),
+            CompareButton(session),
+            Div(hx_target="#container",
+                hx_swap="outerHTML",
+                hx_trigger="keyup[key=='f' || key=='F'] from:body",
+                hx_get=f"/fullscreen?full={'true' if not fullscreen else 'false'}",),
+            cls="table-container"
+        ),
+        RightPanel(session, closed = fullscreen),
+        cls='container',
+        id="container",
+        hx_swap_oob="true" if swap else None
+    )

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

@@ -0,0 +1,12 @@
+from .template import RightPanel, fill_panel, reset_scalar_session
+from .scalars import build_scalar_routes
+from .run_info import build_info_routes
+from .images import build_images_routes
+from .fragments import build_fragment_routes
+
+def build_right_panel_routes(rt):
+    rt("/fillpanel")(fill_panel)
+    build_images_routes(rt)
+    build_scalar_routes(rt)
+    build_info_routes(rt)
+    build_fragment_routes(rt)

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

@@ -0,0 +1,57 @@
+from typing import *
+from datetime import datetime, timedelta
+from fasthtml.common import *
+from markupsafe import Markup
+
+def CopyToClipboard(text: str, cls):
+    return Div(
+        Span(text, cls='copy-text' + ' ' + cls),
+        Span(
+            I(cls=f'fas fa-copy copy-icon default-icon {cls}'),
+            I(cls=f'fas fa-check copy-icon check-icon {cls}'),
+            cls='copy-icon-container',
+        ),
+        onclick='copyToClipboard(this)',
+        cls='copy-container'
+    )
+
+def ConfigView(runID: int):
+    from __main__ import rTable
+
+    # Config
+    cfg_text = rTable.load_config(runID)
+    cfg_parts = cfg_text.splitlines()
+    cfg = []
+    for part in cfg_parts:
+        cfg.append(P(Markup(part), cls="config-part"))
+
+    # Cli
+    row = rTable.fetch_experiment(runID)
+    command_line = row[5]
+    if row[4] == "":
+        lines = [P(Markup(""), cls="config-part")]
+    else:
+        cli = {keyvalue.split("=")[0]: "=".join(keyvalue.split("=")[1:]) for keyvalue in row[4].split(" ")}
+        lines = [P(Markup(f"- {key}: {value}"), cls="config-part") for key, value in cli.items()]
+    return Div(
+        Div(
+            H2("Configuration"),
+            Div(
+                *cfg,
+                cls="file-view",
+            )
+        ),
+        Div(
+            H2("Cli"),
+            Div(
+                *lines,
+                cls="file-view",
+            ),
+
+            Div(
+                CopyToClipboard(command_line, cls=""),
+                cls="file-view",
+                style="margin-top: 2em;"
+            )
+        )
+    )

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

@@ -0,0 +1,133 @@
+from fasthtml.common import *
+from starlette.responses import Response
+from typing import *
+from deepboard.gui.components import Modal, SplitSelector, StatLine, ArtefactGroup
+
+def _get_fragment_groups(socket, type: Literal["RAW", "HTML"]):
+    if type == "RAW":
+        fragments = socket.read_text()
+    else:
+        fragments = socket.read_fragment()
+
+    index = list({(fragment["step"], fragment["epoch"], fragment["run_rep"], fragment["split"]) for fragment in fragments})
+
+    splits = list({elem[3] for elem in index})
+
+    # Package fragments
+    frag_groups = {}
+    for key in index:
+        cropped_key = key[:-1]  # Remove split
+        if cropped_key not in frag_groups:
+            frag_groups[cropped_key] = {split: [] for split in splits}
+
+    for fragment in fragments:
+        key = fragment["step"], fragment["epoch"], fragment["run_rep"]
+        split = fragment["split"]
+        frag_groups[key][split].append(fragment["fragment"])
+
+    # Sort fragments groups by step, and run_rep
+    return dict(sorted(frag_groups.items(), key=lambda x: (x[0][0], x[0][2])))
+
+
+def TextComponent(text: str):
+    return Div(
+        P(text, cls="fragment-text"),
+        cls="fragment-text-container"
+    )
+
+def HTMLComponent(html_str: str):
+    # Return whatever is in html_str as a HTML component
+    return NotStr(html_str)
+
+def FragmentCard(runID: int, step: int, epoch: Optional[int], run_rep: int, frag_type: Literal["RAW", "HTML"],
+              selected: Optional[str] = None):
+    from __main__ import rTable
+
+    socket = rTable.load_run(runID)
+    data = _get_fragment_groups(socket, type=frag_type)
+
+    if (step, epoch, run_rep) not in data:
+        avail_splits = []
+        fragments = []
+    else:
+        fragment_splits = data[(step, epoch, run_rep)]
+        print(fragment_splits)
+        avail_splits = list(fragment_splits.keys())
+        avail_splits.sort()
+        if selected is None:
+            selected = avail_splits[0]
+        fragments = fragment_splits[selected]
+
+    return Div(
+        Div(
+            SplitSelector(runID, avail_splits, selected=selected, step=step, epoch=epoch, run_rep=run_rep,
+                          type=frag_type, path="/fragments/change_split"),
+            Div(
+                StatLine("Step", str(step)),
+                StatLine("Epoch", str(epoch) if epoch is not None else "N/A"),
+                StatLine("Run Repetition", str(run_rep)),
+                cls="artefact-stats-column"
+            ),
+            cls="artefact-card-header",
+        ),
+        ArtefactGroup(*[
+            TextComponent(frag_content) if frag_type == "RAW" else HTMLComponent(frag_content)
+            for frag_content in fragments
+        ]),
+        id=f"artefact-card-{step}-{epoch}-{run_rep}",
+        cls="artefact-card",
+    )
+
+def FragmentTab(session, runID, type: Literal["RAW", "HTML"], swap: bool = False):
+    from __main__ import rTable
+    socket = rTable.load_run(runID)
+
+    fragment_groups = _get_fragment_groups(socket, type=type)
+    return Div(
+        *[
+            FragmentCard(runID, step, epoch, run_rep, frag_type=type)
+            for step, epoch, run_rep in fragment_groups.keys()
+        ],
+        style="display; flex; flex-direction: column; align-items: center; justify-content: center;",
+        id="fragment-tab",
+        hx_swap_oob="true" if swap else None,
+    )
+
+
+def fragment_enable(runID, type: Literal["RAW", "HTML"]):
+    """
+    Check if some fragments/text are logged and available for the runID. If not, we consider disable it.
+    :param runID: The runID to check.
+    :return: True if scalars are available, False otherwise.
+    """
+    from __main__ import rTable
+    socket = rTable.load_run(runID)
+    if type == "RAW":
+        return len(socket.read_text()) > 0
+    else:
+        return len(socket.read_fragment()) > 0
+
+# routes
+def build_fragment_routes(rt):
+    rt("/fragments/change_split")(change_split)
+
+
+def change_split(session, runID: int, step: int, epoch: Optional[int], run_rep: int, split_select: str, type: str):
+    """
+    Change the split for the fragment.
+    :param session: The session object.
+    :param step: The step of the fragment.
+    :param epoch: The epoch of the fragment.
+    :param run_rep: The run repetition of the fragments.
+    :param split: The split to change to.
+    :return: The updated fragment card HTML.
+    """
+    return FragmentCard(
+        runID,
+        step,
+        epoch,
+        run_rep,
+        frag_type=type,
+        selected=split_select,
+    )
+

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

@@ -0,0 +1,25 @@
+from typing import *
+from datetime import datetime, timedelta
+from fasthtml.common import *
+from markupsafe import Markup
+
+def HParamsView(runID: int):
+    from __main__ import rTable
+    socket = rTable.load_run(runID)
+    hparams = socket.get_hparams()
+    return Div(
+        Table(
+            Tr(
+                Th('Parameter'),
+                Th('Value'),
+            ),
+            *[
+                Tr(
+                    Td(key),
+                    Td(value),
+                )
+                for key, value in hparams.items()
+            ],
+            cls="hparams-table",
+        )
+    )