arbok-inspector 0.0.0__py3-none-any.whl

arbok_inspector/pages/database_browser.py

@@ -0,0 +1,159 @@
+import time
+from nicegui import ui, app
+from arbok_inspector.state import inspector
+from arbok_inspector.pages.run_view import run_page
+from arbok_inspector.widgets.update_day_selecter import update_day_selecter
+from arbok_inspector.widgets.update_run_selecter import update_run_selecter
+from arbok_inspector.classes.run import Run
+
+DAY_GRID_COLUMN_DEFS = [
+    {'headerName': 'Day', 'field': 'day'},
+]
+
+small_col_width = 30
+RUN_GRID_COLUMN_DEFS = [
+    {'headerName': 'Run ID', 'field': 'run_id', "width": small_col_width},
+    {'headerName': 'Name', 'field': 'name'},
+    {'headerName': 'Exp ID', 'field': 'exp_id', "width": small_col_width},
+    {'headerName': '# Results', 'field': 'result_counter', "width": small_col_width},
+    {'headerName': 'Started', 'field': 'run_timestamp', "width": small_col_width},
+    {'headerName': 'Finish', 'field': 'completed_timestamp', "width": small_col_width},
+]
+RUN_PARAM_DICT = {
+    'run_id': 'Run ID',
+    'exp_id': 'Experiment ID',
+    'result_counter': '# results',
+    'run_timestamp': 'Started',
+    'completed_timestamp': 'Completed',
+}
+AGGRID_STYLE = 'height: 95%; min-height: 0;'
+EXPANSION_CLASSES = 'w-full p-0 gap-1 border border-gray-400 rounded-lg no-wrap items-start'
+
+shared_data = {}
+
+@ui.page('/browser')
+async def database_browser_page():
+    _ = await ui.context.client.connected()
+    app.storage.general["avg_axis"] = None
+    app.storage.general["result_keywords"] = None
+    app.storage.tab["avg_axis_input"] = None
+    app.storage.tab["result_keyword_input"] = None
+    offset_minutes = await ui.run_javascript('new Date().getTimezoneOffset()')
+    offset_hours = -float(offset_minutes) / 60
+    app.storage.general["timezone"] = offset_hours
+    print(f"TIMEZONE: UTC{offset_hours}")
+
+    """Database general page showing the selected database"""
+    grids = {'day': None, 'run': None}
+    with ui.column().classes('w-full h-screen'):
+        ui.add_head_html('<title>Arbok Inspector - Database general</title>')
+        with ui.row().classes('w-full items-center justify-between'):
+            ui.label('Arbok Inspector').classes('text-3xl font-bold mb-1')
+            
+            with ui.expansion('Database info and settings', icon='info', value=True)\
+                .classes(EXPANSION_CLASSES).props('expand-separator'):
+                build_database_info_section(grids)
+
+        with ui.row().classes('w-full flex-1'):
+            build_day_selecter(grids)
+            build_run_selecter(grids)
+
+def open_run_page(run_id: int):
+    # with ui.dialog() as dialog, ui.card():
+    #     ui.label(f'loading run {run_id} ...').classes(
+    #         'text-3xl font-bold mb-1')
+    # app.storage.general["run"] = Run(run_id)
+    # time.sleep(2)
+    # dialog.close()
+    shared_data['test'] = "hello"
+    app.storage.general["avg_axis"] = app.storage.tab["avg_axis_input"].value
+    app.storage.general["result_keywords"] = app.storage.tab["result_keyword_input"].value
+    print(f"Result Keywords:")
+    print(app.storage.general['result_keywords'])
+    ui.navigate.to(f'/run/{run_id}', new_tab=True)
+
+def build_database_info_section(grids):
+    """Build the database information and settings section."""
+    with ui.row().classes('w-full'):
+        build_info_section()
+        build_settings_section(grids)
+
+def build_info_section():
+    """Build the database information section."""
+    with ui.column().classes('w-1/3'):
+        ui.label('Database Information').classes('text-xl font-semibold mb-4')
+        if inspector.database_path:
+            ui.label(f'Database Path: {str(inspector.database_path)}').classes()
+        else:
+            ui.label('No database selected').classes('text-lg text-red-500')
+        
+def build_settings_section(grids):
+    """Build the database settings section."""
+    with ui.column().classes('w-1/2'):
+        with ui.row().classes('w-full'):
+            app.storage.tab["result_keyword_input"] = ui.input(
+                label = 'auto-plot keywords',
+                placeholder="e.g:\t\t[ ( 'Q1' , 'state' ), 'feedback' ]"
+                ).props('rounded outlined dense')\
+                .classes('w-full')\
+                .tooltip("""
+                    Selects all results that contain the specified keywords in their name.<br>
+                    Can be a single keyword (string) or a tuple of keywords.<br>
+                    The latter one requires all keywords to be present in the result name.<br>
+
+                    The given example would select all results that contain 'Q1' and 'state' in their name<br>
+                    or all results that contain 'feedback' in their name.
+                """).props('v-html')
+            app.storage.tab["avg_axis_input"] = ui.input(
+                label = 'average-axis keyword',
+                value = "iteration"
+                ).props('rounded outlined dense')\
+                .classes('w-full')
+        with ui.row().classes('w-full justify-start'):
+            ui.button(
+                text = 'Select New Database',
+                on_click=lambda: ui.navigate.to('/'),
+                color='purple').classes()
+            ui.button(
+                text = 'Reload',
+                on_click=lambda: update_day_selecter(grids['day']),
+                color = '#4BA701'
+                ).classes()
+
+def build_day_selecter(grids):
+    """Build the day selecter grid."""
+    with ui.column().style('width: 120px;').classes('h-full'):
+        grids['day'] = ui.aggrid(
+            {
+                'defaultColDef': {'flex': 1},
+                'columnDefs': DAY_GRID_COLUMN_DEFS,
+                'rowData': {},
+                'rowSelection': 'multiple',
+            },
+            theme = 'ag-theme-balham-dark')\
+            .classes('text-sm ag-theme-balham-dark')\
+            .style(AGGRID_STYLE)\
+            .on(
+                type = 'cellClicked',
+                handler = lambda event: update_run_selecter(
+                    grids['run'], event.args["value"], RUN_GRID_COLUMN_DEFS)
+            )
+        update_day_selecter(grids['day'])
+
+def build_run_selecter(grids):
+    """Build the run selecter grid."""
+    with ui.column().classes('flex-1').classes('h-full'):
+        grids['run'] = ui.aggrid(
+            {
+                'defaultColDef': {'flex': 1},
+                'columnDefs': RUN_GRID_COLUMN_DEFS,
+                'rowData': {},
+                'rowSelection': 'multiple',
+            },
+            #theme = 'ag-theme-balham-dark'
+        ).classes('ag-theme-balham-dark').style(
+            AGGRID_STYLE
+        ).on(
+            'cellClicked',
+            lambda event: open_run_page(event.args['data']['run_id'])
+        )

arbok_inspector/pages/greeter.py

@@ -0,0 +1,35 @@
+
+from nicegui import ui
+from arbok_inspector.state import inspector
+
+@ui.page('/')
+async def greeter_page():
+    """Main page that starts with file selection"""
+    ui.add_head_html('<title>Arbok Inspector 🐍</title>')
+
+    # Show initial file selection dialog
+    with ui.dialog() as dialog, ui.card().classes('w-96'):
+        # Store dialog reference so we can close it later
+        inspector.initial_dialog = dialog
+        dialog.props('persistent')
+
+        ui.label('Welcome to Arbok Inspector').classes('text-h6 mb-4')
+        ui.image('https://microsoft.github.io/Qcodes/_images/qcodes_logo.png')
+        ui.label('Please enter the path to your QCoDeS database file'
+                 ).classes('text-body1 mb-4')
+        ui.label('Database File Path').classes('text-subtitle2 mb-2')
+        path_input = ui.input(
+            label='Database file path',
+            placeholder='C:/path/to/your/database.db'
+        ).classes('w-full mb-2')
+        ui.button(
+            text = 'Load Database',
+            on_click=lambda: inspector.handle_path_input(path_input),
+            icon='folder_open',
+            color='purple').classes('mb-4 w-full')
+        ui.separator()
+        ui.label('Supported formats: .db, .sqlite, .sqlite3'
+                 ).classes('text-caption text-grey')
+    
+    # Auto-open the dialog
+    dialog.open()

arbok_inspector/pages/run_view.py

@@ -0,0 +1,280 @@
+"""Run view page showing the data and plots for a specific run"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import json
+import importlib.resources as resources
+
+from nicegui import ui, app
+
+from arbok_inspector.widgets.build_xarray_grid import build_xarray_grid
+from arbok_inspector.widgets.build_xarray_html import build_xarray_html
+from arbok_inspector.widgets.json_plot_settings_dialog import JsonPlotSettingsDialog
+from arbok_inspector.helpers.unit_formater import unit_formatter
+from arbok_inspector.classes.run import Run
+
+from arbok_inspector.classes.dim import Dim
+
+RUN_TABLE_COLUMNS = [
+    {'field': 'name', 'filter': 'agTextColumnFilter', 'floatingFilter': True},
+    {'field': 'size'},
+    {'field': 'x', 'checkboxSelection': True},
+    {'field': 'y', 'checkboxSelection': True},
+    {'field': 'average', 'checkboxSelection': True},
+]
+
+AXIS_OPTIONS = ['average', 'select_value', 'y-axis', 'x-axis']
+
+EXPANSION_CLASSES = 'w-full p-0 gap-1 border border-gray-400 rounded-lg no-wrap items-start'
+
+
+@ui.page('/run/{run_id}')
+async def run_page(run_id: str):
+    """
+    Page showing the details and plots for a specific run.
+
+    Args:
+        run_id (str): ID of the run to display
+    """
+    ui.page_title(f"{run_id}")
+    _ = await ui.context.client.connected()
+    # run = app.storage.general["run"] # Run(int(run_id))
+    run = Run(int(run_id))
+
+    app.storage.tab["placeholders"] = {'plots': None}
+    app.storage.tab["run"] = run
+    with resources.files("arbok_inspector.configurations").joinpath("1d_plot.json").open("r") as f:
+        app.storage.tab["plot_dict_1D"] = json.load(f)
+    with resources.files("arbok_inspector.configurations").joinpath("2d_plot.json").open("r") as f:
+        app.storage.tab["plot_dict_2D"] = json.load(f)
+
+    ui.label(f'Run Page for ID: {run_id}').classes('text-2xl font-bold')
+    with ui.column().classes('w-full gap-1'):
+        with ui.expansion('Coordinates and results', icon='checklist', value=True)\
+            .classes(EXPANSION_CLASSES).props('expand-separator'):
+            with ui.row().classes('w-full gap-4 no-wrap items-start'):
+                with ui.column().classes('w-2/3 gap-2'):
+                    ui.label("Coordinates:").classes('text-lg font-semibold')
+                    for i, _ in run.parallel_sweep_axes.items():
+                        add_dim_dropdown(sweep_idx = i)
+                with ui.column().classes('w-1/3 gap-2'):
+                    ui.label("Results:").classes('text-lg font-semibold')
+                    for i, result in enumerate(run.full_data_set):
+                        value = False
+                        if result in run.plot_selection:
+                            value = True
+                        ui.checkbox(
+                            text = result.replace("__", "."),
+                            value = value,
+                            on_change = lambda e, r=result: run.update_plot_selection(e.value, r),
+                        ).classes('text-sm h-4').props('color=purple')
+        with ui.expansion('Plots', icon='stacked_line_chart', value=True)\
+            .classes(EXPANSION_CLASSES):
+            with ui.row().classes('w-full p-2 gap-2 items-center rounded-md border border-neutral-600 bg-neutral-800 text-sm'):
+                
+                ui.button(
+                    text='Update',
+                    icon='refresh',
+                    color='green',
+                    on_click=lambda: build_xarray_grid(),
+                ).classes('h-8 px-2')
+
+                ui.button(
+                    text='Debug',
+                    icon='info',
+                    color='red',
+                    on_click=lambda: print_debug(run),
+                ).classes('h-8 px-2')
+
+                dialog_1d = JsonPlotSettingsDialog('plot_dict_1D')
+                dialog_2d = JsonPlotSettingsDialog('plot_dict_2D')
+
+                ui.button(
+                    text='1D settings',
+                    color='pink',
+                    on_click=dialog_1d.open,
+                ).classes('h-8 px-2')
+
+                ui.button(
+                    text='2D settings',
+                    color='orange',
+                    on_click=dialog_2d.open,
+                ).classes('h-8 px-2')
+
+                ui.number(
+                    label='# per col',
+                    value=2,
+                    format='%.0f',
+                    on_change=lambda e: set_plots_per_column(e.value),
+                ).props('dense outlined').classes('w-20 h-8 text-xs mb-2')
+                ui.button(
+                    icon = 'file_download',
+                    text = 'full dataset',
+                    color = 'blue',
+                    on_click=download_full_dataset,
+                ).classes('h-8 px-2')
+                ui.button(
+                    icon = 'file_download',
+                    text = 'data selection',
+                    color='darkblue',
+                    on_click=download_data_selection,
+                ).classes('h-8 px-2')
+                #.style('line-height: 1rem; padding-top: 0; padding-bottom: 0;')
+            app.storage.tab["placeholders"]["plots"] = ui.row().classes('w-full p-4')
+            build_xarray_grid()
+        with ui.expansion('xarray summary', icon='summarize', value=False)\
+            .classes(EXPANSION_CLASSES):
+            build_xarray_html()
+        with ui.expansion('analysis', icon='science', value=False)\
+            .classes(EXPANSION_CLASSES):
+            with ui.row():
+                ui.label("Working on it!  -Andi").classes('text-lg font-semibold')
+        with ui.expansion('metadata', icon='numbers', value=False)\
+            .classes(EXPANSION_CLASSES):
+            ui.row().classes('w-full p-4')
+                
+
+def add_dim_dropdown(sweep_idx: int):
+    """
+    Add a dropdown to select the dimension option for a given sweep index.
+
+    Args:
+        sweep_idx (int): Index of the sweep to add the dropdown for
+    """
+    run = app.storage.tab["run"]
+    width = 'w-1/2' if run.together_sweeps else 'w-full'
+    dim = run.sweep_dict[sweep_idx]
+    local_placeholder = {"slider": None}
+    with ui.column().classes('w-full no-wrap items-center gap-1'):
+        ui_element = ui.select(
+            options = AXIS_OPTIONS,
+            value = str(dim.option),
+            label = f'{dim.name.replace("__", ".")}',
+            on_change = lambda e: update_dim_selection(
+                dim, e.value, local_placeholder["slider"])
+        ).classes(f"{width} text-sm m-0 p-0").props('dense')
+        dim.ui_selector = ui_element
+        if run.together_sweeps:
+            dims_names = run.parallel_sweep_axes[sweep_idx]
+            ui.radio(
+                options = dims_names,
+                value=dim.name,
+                on_change = lambda e: update_sweep_dim_name(dim, e.value)
+                ).classes(width).props('dense')
+        local_placeholder["slider"] = ui.column().classes('w-full')
+        if dim.option == 'select_value':
+            build_dim_slider(run, dim, local_placeholder["slider"])
+
+def update_dim_selection(dim: Dim, value: str, slider_placeholder):
+    """
+    Update the dimension/sweep selection and rebuild the plot grid.
+
+    Args:
+        dim (Dim): The dimension object to update
+        value (str): The new selection value
+        slider_placeholder: The UI placeholder to update
+    """
+    run = app.storage.tab["run"]
+    if slider_placeholder is not None:
+        slider_placeholder.clear()
+    print(value)
+    if value == 'average':
+        run.update_subset_dims(dim, 'average')
+        dim.option = 'average'
+    if value == 'select_value':  
+        with slider_placeholder:
+            build_dim_slider(run, dim, slider_placeholder)
+    else:
+        run.update_subset_dims(dim, value)
+        dim.option = value
+    build_xarray_grid()
+
+def build_dim_slider(run: Runm, dim: Dim, slider_placeholder):
+    """
+    Build a slider for selecting the index of a dimension.
+
+    Args:
+        dim (Dim): The dimension object
+        slider_placeholder: The UI placeholder to add the slider to
+    """
+    dim_size = run.full_data_set.sizes[dim.name]
+    with ui.row().classes("w-full items-center"):
+        with ui.column().classes('flex-grow'):
+            slider = ui.slider(
+                min=0, max=dim_size - 1, step=1, value=0,
+                on_change=lambda e: run.update_subset_dims(dim, 'select_value', e.value),
+                ).classes('flex-grow')\
+                .props('color="purple" markers label-always')
+        label = ui.html('').classes('shrink-0 text-right px-2 py-1 bg-purple text-white rounded-lg text-xs font-normal text-center')
+        update_value_from_dim_slider(label, slider, dim, plot = False)
+        slider.on(
+            'update:model-value',
+            lambda e: update_value_from_dim_slider(label, slider, dim),
+            throttle=0.2, leading_events=False)
+
+def update_value_from_dim_slider(label, slider, dim: Dim, plot = True):
+    """
+    Update the label next to the slider with the current value and unit.
+    
+    Args:
+        label: The UI label to update
+        slider: The UI slider to get the value from
+        dim (Dim): The dimension object
+    """
+    run = app.storage.tab["run"]
+    label_txt = f' {unit_formatter(run, dim, slider.value)} '
+    label.set_content(label_txt)
+    if plot:
+        build_xarray_grid()
+
+def set_plots_per_column(value: int):
+    """
+    Set the number of plots to display per column.
+
+    Args:
+        value (int): The number of plots per column
+    """
+    run = app.storage.tab["run"]
+    ui.notify(f'Setting plots per column to {value}', position='top-right')
+    run.plots_per_column = int(value)
+    build_xarray_grid()
+
+
+def update_sweep_dim_name(dim: Dim, new_name: str):
+    """
+    Update the name of the dimension in the sweep dict and the dim object.
+    
+    Args:
+        dim (Dim): The dimension object to update
+        new_name (str): The new name for the dimension
+    """
+    run = app.storage.tab["run"]
+    dim.name = new_name
+    dim.ui_selector.label = new_name.replace("__", ".")
+    build_xarray_grid()
+
+def print_debug(run: Run):
+    print("\nDebugging Run:")
+    for key, val in run.dim_axis_option.items():
+        if isinstance(val, list):
+            val_str = str([d.name for d in val])
+        elif isinstance(val, Dim):
+            val_str = val.name
+        else:
+            val_str = str(val)
+        print(f"{key}: \t {val_str}")
+
+def download_full_dataset():
+    """Download the full dataset as a NetCDF file."""
+    run = app.storage.tab["run"]
+    local_path = f'./run_{run.run_id}.nc'
+    run.full_data_set.to_netcdf(local_path)
+    ui.download.file(local_path)
+    os.remove(local_path)
+
+def download_data_selection():
+    """Download the current data selection as a NetCDF file."""
+    run = app.storage.tab["run"]
+    local_path = f'./run_{run.run_id}_selection.nc'
+    run.last_subset.to_netcdf(local_path)
+    ui.download.file(local_path)
+    os.remove(local_path)

arbok_inspector/state.py

@@ -0,0 +1,56 @@
+from nicegui import ui
+from pathlib import Path
+import asyncio
+from typing import Optional
+import sqlite3
+from qcodes.dataset import initialise_or_create_database_at
+
+class ArbokInspector:
+    def __init__(self):
+        self.database_path: Optional[Path] = None
+        self.initial_dialog = None
+        self.csonn = None
+        self.cursor = None
+        
+    def connect_database(self):
+        self.conn = sqlite3.connect(self.database_path)
+        self.conn.row_factory = sqlite3.Row
+        self.cursor = self.conn.cursor()
+        initialise_or_create_database_at(self.database_path)
+
+    def handle_path_input(self, path_input):
+        """Handle manual path input"""
+        if path_input.value:
+            try:
+                file_path = Path(path_input.value)
+                if file_path.exists():
+                    self.database_path = file_path
+                    ui.notify(f'Database path set: {file_path.name}', type='positive')
+                    # Only close dialog if path is valid and exists
+                    try:
+                        self.connect_database()
+                        if self.initial_dialog:
+                            self.initial_dialog.close()
+                        self.show_database_path()
+                    except sqlite3.Error as e:
+                        ui.notify(f'Error connecting to database: {str(e)}', type='negative')
+                        # Don't close dialog - let user try again
+                else:
+                    ui.notify('File does not exist', type='negative')
+                    # Don't close dialog - let user try again
+            except Exception as ex:
+                ui.notify(f'Error: {str(ex)}', type='negative')
+                # Don't close dialog on error
+        else:
+            ui.notify('Please enter a file path', type='warning')
+            # Don't close dialog if no path entered
+    
+    def show_database_path(self):
+        """Display the database path on the main page"""
+        # Navigate to a database browser page instead of clearing
+        ui.navigate.to('/browser')
+
+# Initialize the application
+inspector = ArbokInspector()
+inspector.database_path = 'test.db'  # For development purposes only
+inspector.connect_database()

arbok_inspector/test_main.py

@@ -0,0 +1,65 @@
+import numpy as np
+import xarray as xr
+import plotly.express as px
+from nicegui import ui
+
+# --- Create a sample 4D DataArray ---
+data = np.random.rand(5, 10, 20, 30)  # shape: time, depth, y, x
+coords = {
+    'time': np.arange(5),
+    'depth': np.linspace(0, 100, 10),
+    'y': np.linspace(-5, 5, 20),
+    'x': np.linspace(-5, 5, 30),
+}
+array = xr.DataArray(data, dims=('time', 'depth', 'y', 'x'), coords=coords)
+
+# --- Define axes to plot ---
+x_dim = 'x'
+y_dim = 'y'
+slider_dims = [dim for dim in array.dims if dim not in (x_dim, y_dim)]
+
+# --- UI State ---
+slider_values = {dim: 0 for dim in slider_dims}
+plot_container = ui.row().classes('w-full justify-center')
+
+# --- Heatmap update function ---
+def update_plot():
+    # Index the array using current slider values
+    sel = {dim: slider_values[dim] for dim in slider_dims}
+    slice_2d = array.isel(**sel)
+
+    # Convert to plotly figure
+    fig = px.imshow(
+        slice_2d.values,
+        labels={'x': x_dim, 'y': y_dim},
+        x=array.coords[x_dim].values,
+        y=array.coords[y_dim].values,
+        color_continuous_scale='Viridis',
+    )
+    fig.update_layout(title=f'{x_dim} vs {y_dim} | ' + ', '.join([f'{dim}={slider_values[dim]}' for dim in slider_dims]))
+
+    plot_container.clear()
+    with plot_container:
+        ui.plotly(fig).classes('max-w-3xl max-h-96')
+
+# --- Create sliders for all non-plotted dimensions ---
+for dim in slider_dims:
+    max_index = len(array.coords[dim]) - 1
+    def make_slider(d=dim):
+        def on_change(val):
+            slider_values[d] = int(val)
+            update_plot()
+        ui.slider(
+            min=0,
+            max=max_index,
+            value=0,
+            step=1,
+            on_change=on_change,
+            #abel=f'{d} ({array.coords[d].values[0]})'
+        ).props('label-always').classes('w-full')
+    make_slider()
+
+# --- Initial plot ---
+update_plot()
+
+ui.run()