arbok-inspector 1.3.0__py3-none-any.whl

arbok_inspector/__init__.py

@@ -0,0 +1 @@
+# from .database_browser import database_browser_page

arbok_inspector/analysis/analysis_base.py

@@ -0,0 +1,29 @@
+"""Module containing AnalysisBase class"""
+
+class AnalysisBase:
+    """Base class for analysis classes"""
+    run_id = None
+    xr_data = None
+
+    def find_axis_from_keyword(self, keyword: str) -> str:
+        """
+        Find the axis corresponding to a keyword in the analysis
+        Args:
+            keyword (str): Keyword to search for
+        Returns:
+            axis (int): Axis corresponding to keyword
+        """
+        axes = []
+        for axis in self.xr_data.dims:
+            if keyword in axis:
+                axes.append(axis)
+        if len(axes) == 0:
+            raise ValueError(
+                f"Axis not found for keyword {keyword}. "
+                f"Dims are {self.xr_data.dims}"
+                )
+        elif len(axes) > 1:
+            raise ValueError(
+                f"More than one axis found for keyword {keyword}: {axes}")
+        else:
+            return axes[0]

arbok_inspector/analysis/prepare_data.py

@@ -0,0 +1,118 @@
+"""Module containing prepare_data function for analysis tools"""
+
+from matplotlib.pylab import f
+from qcodes.dataset.data_set import load_by_id, DataSet
+import xarray as xr
+import numpy as np
+import matplotlib.pyplot as plt
+
+def prepare_and_avg_data(
+    run: int | DataSet | xr.Dataset | xr.DataArray,
+    readout_name: str,
+    avg_axes: str | list = 'auto'
+    ) -> tuple[int | None, xr.DataArray, np.ndarray]:
+    """
+    Prepares the data for plotting. Takes either a run id, a qcodes dataset,
+    an xarray dataset or an xarray data-array and returns the run id, the xarray
+    data-array and the numpy data-array.
+    This is done to allow different input types for the data while keeping the
+    same output format.
+    
+    Args:
+        run (int | DataSet | xr.Dataset | xr.DataArray): Run id, qcodes dataset'
+            xarray dataset or xarray data-array
+        readout_name (str): Name of the readout observable
+    """
+    xdata_array = None
+    if avg_axes is None:
+        avg_axes = []
+    if isinstance(run, int):
+        data = load_by_id(run)
+        xdataset = data.to_xarray_dataset()
+        run_id = run
+    elif isinstance(run, DataSet):
+        data = run
+        run_id = data.run_id
+        xdataset = data.to_xarray_dataset()
+    elif isinstance(run, xr.Dataset):
+        xdataset = run
+        run_id = xdataset.attrs['run_id']
+    elif isinstance(run, xr.DataArray):
+        xdataset = None
+        xdata_array = run
+        run_id = None
+    else:
+        raise ValueError(
+            "Invalid input type for run. "
+            "Must be run-ID, DataSet or xr.Dataset or xr.DataArray. "
+            f"Is {type(run)}"
+            )
+    if xdataset is not None:
+        if readout_name not in xdataset.data_vars:
+            readout_name = find_data_variable_from_keyword(xdataset, readout_name)
+        xdata_array = xdataset[readout_name]
+    ### Average over specified axes
+    xdata_array = avg_dataarray(xdata_array, avg_axes)
+    np_data = xdata_array.to_numpy()
+    return run_id, xdata_array, np_data
+
+def find_data_variable_from_keyword(
+        xdata_array: xr.DataArray, keyword: str | tuple) -> str:
+    """
+    Find the data variable corresponding to a keyword in the data-array.
+    
+    Args:
+        xdata_array (xr.DataArray): xarray data-array to search in
+        keyword (str): Keyword to search for
+    Returns:
+        data_variable (str): Data variable corresponding to keyword
+    """
+    if isinstance(keyword, str):
+        keyword = (keyword,)
+    if not isinstance(keyword, tuple):
+        raise ValueError(
+            f"Keyword must be a string or a tuple. Is {type(keyword)}")
+    data_variables = []
+    for data_variable in xdata_array.data_vars:
+        if all([subkey in str(data_variable) for subkey in keyword]):
+            data_variables.append(data_variable)
+    if len(data_variables) == 0:
+        raise ValueError(
+            f"Data variable not found for keyword {keyword}. "
+            f"Data variables are {xdata_array.data_vars}"
+            )
+    elif len(data_variables) > 1:
+        raise ValueError(
+            f"More than one data variable found for keyword {keyword}: "
+            f"{[str(var) for var in data_variables]}")
+    else:
+        return data_variables[0]
+
+def avg_dataarray(xdata_array: xr.DataArray, avg_axes: str | list = 'auto'):
+    """
+    Averages the data-array over the specified axes. If no axes are specified
+    the data-array is averaged over all axes.
+    
+    Args:
+        xdata_array (xr.DataArray): xarray data-array to be averaged
+        avg_axes (str | list): Axes to average over
+    """
+    if avg_axes is None:
+        avg_axes = []
+    if isinstance(avg_axes, str):
+        ### If 'auto' is given, find all axes with 'iteration' in the name
+        if avg_axes == 'auto':
+            avg_axes = []
+            for dim in xdata_array.dims:
+                if 'iteration' in dim:
+                    avg_axes.append(dim)
+        else:
+            avg_axes = [avg_axes]
+    ### Average over specified axes
+    for axis in avg_axes:
+        if hasattr(xdata_array, axis):
+            xdata_array = xdata_array.mean(axis)
+        else:
+            raise KeyError(
+                f"Avg. axis {axis} not found in xarray data-array")
+    return xdata_array

arbok_inspector/classes/base_run.py

@@ -0,0 +1,275 @@
+"""
+Run class representing a single run of the experiment.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from abc import ABC, abstractmethod
+import ast
+import re
+import io
+import json
+from qcodes.dataset import load_by_id
+from nicegui import ui, app
+import xarray as xr
+
+
+
+from arbok_inspector.classes.dim import Dim
+from arbok_inspector.widgets.build_xarray_grid import build_xarray_grid
+from arbok_inspector.state import ArbokInspector, inspector
+
+if TYPE_CHECKING:
+    from qcodes.dataset.data_set import DataSet
+    from xarray import Dataset
+
+AXIS_OPTIONS = ['average', 'select_value', 'y-axis', 'x-axis']
+
+class BaseRun(ABC):
+    """
+    Class representing a run with its data and methods
+    """
+    def __init__(self, run_id: int):
+        """
+        Constructor for Run class
+        
+        Args:
+            run_id (int): ID of the run
+        """
+        self.run_id: int = run_id
+        self.title: str = f'Run ID: {run_id}  (-> add experiment)'
+        self.inspector: ArbokInspector =  inspector
+        self._database_columns = self._get_database_columns()
+        self.full_data_set: Dataset = self._load_dataset()
+        self.last_subset: Dataset = self.full_data_set
+
+        self.parallel_sweep_axes: dict = {}
+        self.sweep_dict: dict[int, Dim] = {}
+        self.load_sweep_dict()
+        self.dims: list[Dim] = list(self.sweep_dict.values())
+        self.dim_axis_option: dict[str, str|list[Dim]] = self.set_dim_axis_option()
+        print(self.dims)
+
+        self.plot_selection: list[str] = self.select_results_by_keywords(
+            app.storage.general["result_keywords"]
+        )
+        print(f"Initial plot selection: {self.plot_selection}")
+        self.plots_per_column: int = 2
+
+    @property
+    def database_columns(self) -> dict[str, dict[str, str]]:
+        """Column names of database, with their values and shown labels"""
+        return self._database_columns
+
+    @abstractmethod
+    def _get_database_columns(self) -> dict[str, dict[str, str]]:
+        pass
+
+    @abstractmethod
+    def _load_dataset(self) -> Dataset:
+        """
+        Load the dataset for the given run ID from the appropriate database type.
+        
+        Args:
+            run_id (int): ID of the run
+            database_type (str): Type of the database ('qcodes' or 'arbok')
+        Returns:
+            DataSet: Loaded dataset
+        """
+        pass
+
+    @abstractmethod
+    def get_qua_code(self, as_string: bool = False) -> str:
+        """
+        Retrieve the QUA code associated with this run.
+
+        Returns:
+            qua_code (str): The QUA code as a string
+        """
+        pass
+
+    def load_sweep_dict(self):
+        """
+        Load the sweep dictionary from the dataset
+        TODO: check metadata for sweep information!
+        Returns:
+            sweep_dict (dict): Dictionary with sweep information
+            is_together (bool): True if all sweeps are together, False otherwise
+        """
+        self.parallel_sweep_axes = {}
+        dims = self.full_data_set.dims
+        for i, dim in enumerate(dims):
+            dependent_coords = [
+                name for name, coord in self.full_data_set.coords.items() if dim in coord.dims]
+            self.parallel_sweep_axes[i] = dependent_coords
+        self.sweep_dict = {
+            i: Dim(names[0]) for i, names in self.parallel_sweep_axes.items()
+            }
+        return self.sweep_dict
+
+    def set_dim_axis_option(self):
+        """
+        Set the default dimension options for the run in 4 steps:
+        1. Set all iteration dims to 'average'
+        2. Set the innermost dim to 'x-axis' (the last one that is not averaged)
+        3. Set the next innermost dim to 'y-axis'
+        4. Set all remaining dims to 'select_value'
+
+        Returns:
+            options (dict): Dictionary with keys 'average', 'select_value', 'y-axis',
+        """
+        options = {x: [] for x in AXIS_OPTIONS}
+        print(f"Setting average to {app.storage.general['avg_axis']}")
+        for dim in self.dims:
+            if app.storage.general["avg_axis"] is None:
+                break
+            if app.storage.general["avg_axis"] in dim.name:
+                dim.option = 'average'
+                options['average'].append(dim)
+        for dim in reversed(self.dims):
+            if dim not in options['average'] and dim != options['x-axis']:
+                dim.option = "x-axis"
+                options['x-axis'] = dim
+                print(f"Setting x-axis to {dim.name}")
+                break
+        for dim in reversed(self.dims):
+            if dim not in options['average'] and dim != options['x-axis']:
+                dim.option = 'y-axis'
+                options['y-axis'] = dim
+                print(f"Setting y-axis to {dim.name}")
+                break
+        for dim in self.dims:
+            if dim not in options['average'] and dim != options['x-axis'] and dim != options['y-axis']:
+                dim.option = 'select_value'
+                options['select_value'].append(dim)
+                dim.select_index = 0
+                print(f"Setting select_value to {dim.name}")
+        return options
+
+    def select_results_by_keywords(self, keywords: list[str|tuple]) -> list[str]:
+        """
+        Select results by keywords in their name.
+        Args:
+            keywords (list): List of keywords to search for
+        Returns:
+            selected_results (list): List of selected result names
+
+        TODO: simplify this! way too complicated
+        """
+        print(f"using keywords: {keywords}")
+        if keywords is None or len(keywords) == 0 or keywords == '':
+            return [next(iter(self.full_data_set.data_vars))]
+        s_quoted = re.sub(r'\b([a-zA-Z_][a-zA-Z0-9_]*)\b', r'"\1"', keywords)
+        try:
+            keywords = ast.literal_eval(s_quoted)
+        except (SyntaxError, ValueError):
+            print(f"Error parsing keywords: {s_quoted}")
+            keywords = []
+            ui.notify(
+                f"Error parsing result keywords: {s_quoted}. Please use a valid Python list.",
+                color='red',
+                position='top-right'
+            )
+        if not isinstance(keywords, list):
+            keywords = [keywords]
+        selected_results = []
+        print(f"using keywords: {keywords}")
+        for result in self.full_data_set.data_vars:
+            for keyword in keywords:
+                if isinstance(keyword, str) and keyword in str(result):
+                    selected_results.append(result)
+                elif isinstance(keyword, tuple) and all(
+                        subkey in str(result) for subkey in keyword):
+                    selected_results.append(result)
+        selected_results = list(set(selected_results))  # Remove duplicates
+        if len(selected_results) == 0:
+            selected_results = [next(iter(self.full_data_set.data_vars))]
+        print(f"Selected results: {selected_results}")
+        return selected_results
+    
+    def update_subset_dims(self, dim: Dim, selection: str, index = None):
+        """
+        Update the subset dimensions based on user selection.
+
+        Args:
+            dim (Dim): The dimension object to update
+            selection (str): The new selection option
+                ('average', 'select_value', 'x-axis', 'y-axis')
+            index (int, optional): The index for 'select_value' option. Defaults to None.
+        """
+        text = f'Updating subset dims: {dim.name} to {selection}'
+        print(text)
+        ui.notify(text, position='top-right')
+
+        ### First, remove old option this dim was on
+        for option in ['average', 'select_value']:
+            if dim in self.dim_axis_option[option]:
+                print(f"Removing {dim.name} from {option}")
+                self.dim_axis_option[option].remove(dim)
+                dim.option = None
+        if dim.option in ['x-axis', 'y-axis']:
+            print(f"Removing {dim.name} from {dim.option}")
+            self.dim_axis_option[dim.option] = None
+
+        ### Now, set new option
+        if selection in ['average', 'select_value']:
+            # dim.ui_selector.value = selection
+            dim.select_index = index
+            self.dim_axis_option[selection].append(dim)
+            return
+        if selection in ['x-axis', 'y-axis']:
+            old_dim = self.dim_axis_option[selection]
+            self.dim_axis_option[selection] = dim
+            if old_dim:
+                # Set previous dim (having this option) to 'select_value'
+                # Required since x and y axis have to be unique
+                print(old_dim)
+                print(f"Updating {old_dim.name} to {dim.name} on {selection}")
+                if old_dim.option in ['x-axis', 'y-axis']:
+                    self.dim_axis_option['select_value'].append(old_dim)
+                    old_dim.option = 'select_value'
+                    old_dim.ui_selector.value = 'select_value'
+                    self.update_subset_dims(old_dim, 'select_value', old_dim.select_index)
+        dim.ui_selector.update()
+
+    def generate_subset(self):
+        """
+        Generate the subset of the full dataset based on the current dimension options.
+        Returns:
+            sub_set (xarray.Dataset): The subset of the full dataset
+        """
+        # TODO: take the averaging out of this! We only want to average if necessary
+        # averaging can be computationally intensive!
+        sub_set = self.full_data_set
+        for avg_axis in self.dim_axis_option['average']:
+            sub_set = sub_set.mean(dim=avg_axis.name)
+        sel_dict = {d.name: d.select_index for d in self.dim_axis_option['select_value']}
+        sub_set = sub_set.isel(**sel_dict).squeeze()
+        self.last_subset = sub_set
+        return sub_set
+
+    def update_plot_selection(self, value: bool, readout_name: str):
+        """
+        Update the plot selection based on user interaction.
+
+        Args:
+            value (bool): True if the result is selected, False otherwise
+            readout_name (str): Name of the result to update
+        """
+        print(f"{readout_name= } {value= }")
+        pretty_readout_name = readout_name.replace("__", ".")
+        if readout_name not in self.plot_selection:
+            self.plot_selection.append(readout_name)
+            ui.notify(
+                message=f'Result {pretty_readout_name} added to plot selection',
+                position='top-right'
+                )
+        else:
+            self.plot_selection.remove(readout_name)
+            ui.notify(
+                f'Result {pretty_readout_name} removed from plot selection',
+                position='top-right'
+            )
+        print(f"{self.plot_selection= }")
+        build_xarray_grid()
+

arbok_inspector/classes/dim.py

@@ -0,0 +1,26 @@
+"""Module for the Dim class."""
+
+class Dim:
+    """
+    Class representing a dimension of the data
+    """
+    def __init__(self, name):
+        """
+       Constructor for Dim class
+        
+        Args:
+            name (str): Name of the dimension
+            
+        Attributes:
+            name (str): Name of the dimension
+            option (str): Option for the dimension (average, select_value, x-axis, y-axis)
+            select_index (int): Index of the selected value for select_value option
+            ui_selector: Reference to the UI element for the dimension
+        """
+        self.name = name
+        self.option = None
+        self.select_index = 0
+        self.ui_selector = None
+
+    def __str__(self):
+        return self.name

arbok_inspector/classes/native_run.py

@@ -0,0 +1,172 @@
+"""Module containing NativeRun class"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from sqlalchemy import select
+from sqlalchemy.orm import DeclarativeBase, mapped_column, Session
+from sqlalchemy.inspection import inspect
+import xarray as xr
+
+from arbok_inspector.state import inspector
+from arbok_inspector.classes.base_run import BaseRun
+
+if TYPE_CHECKING:
+    from qcodes.dataset.data_set import DataSet
+    from xarray import Dataset
+
+COLUMN_LABELS = {}
+
+class NativeRun(BaseRun):
+    """"""
+    def __init__(
+            self,
+            run_id: int
+    ):
+        """
+        Constructor for NativeRun class
+        
+        Args:
+            run_id (int): Run ID of the measurement run
+        """
+        super().__init__(run_id)
+        print("HERE", self.database_columns)
+
+    def _get_database_columns(self) -> dict[str, dict[str, str]]:
+        """
+        Returns column names of database, with this rows values and shown labels
+        """
+        columns_and_values = {}
+        with Session(inspector.database_engine) as session:
+            self.sql_run = session.get(SqlRun, self.run_id)
+            columns_and_values['experiment'] = {
+                'value': self.sql_run.experiment.name}
+            for attr in inspect(self.sql_run).mapper.column_attrs:
+                value = getattr(self.sql_run, attr.key)
+                columns_and_values[attr.key] = {'value': value}
+                if attr.key in COLUMN_LABELS:
+                    label = COLUMN_LABELS[attr.key]
+                    columns_and_values[attr.key]['label'] = label
+            
+            session.expunge(self.sql_run)
+        print(columns_and_values)
+        return columns_and_values
+
+    def _load_dataset(self) -> Dataset:
+        """
+        Loads the dataset from the minio bucket. Results with empty dimensions
+        are dropped
+        """
+        minio_path = inspector.minio_bucket + "/"
+        minio_path += f"{self.sql_run.run_id}_{self.sql_run.uuid}"
+        minio_path += "/data.zarr"
+        print(f"Loading dataset from MinIO path: {minio_path}")
+        store = inspector.minio_filesystem.get_mapper(minio_path)
+        dataset = xr.open_zarr(store, consolidated=True)
+        return dataset
+
+    def get_qua_code(self, as_string: bool = False) -> str:
+        """
+        Retrieve the QUA code associated with this run.
+
+        Returns:
+            qua_code (str): The QUA code as a string
+        """
+        if inspector.database_type == 'native_arbok':
+            with Session(inspector.database_engine) as session:
+                sql_run = session.get(SqlRun, self.run_id)
+
+        minio_path = inspector.minio_bucket + "/"
+        minio_path += f"{self.sql_run.run_id}_{self.sql_run.uuid}"
+        minio_path += "/metadata/qua_program.py"
+        print(f"Loading QUA code from MinIO path: {minio_path}")
+        if as_string:
+            with inspector.minio_filesystem.open(minio_path, mode="r") as f:
+                return f.read()
+        else:
+            with inspector.minio_filesystem.open(minio_path, mode="rb") as f:
+                return io.BytesIO(f.read())
+
+### TODO: IMPORT THOSE CLASSES FROM ELSEWHERE!
+from sqlalchemy.orm import (
+    DeclarativeBase, Mapped, mapped_column, relationship
+)
+
+import uuid
+from sqlalchemy import (
+    BigInteger,
+    Boolean,
+    ForeignKey,
+    Integer,
+    JSON,
+    String,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.dialects.postgresql import ARRAY, JSONB, UUID
+
+class Base(DeclarativeBase):
+    pass
+
+class SqlRun(Base):
+    __tablename__ = "runs"
+
+    ### Run metadata
+    run_id: Mapped[int] = mapped_column(
+        Integer, primary_key=True, autoincrement=True)
+    uuid: Mapped[str] = mapped_column(
+        UUID(as_uuid=True), default=uuid.uuid4, unique=True, nullable=False)
+    exp_id: Mapped[int] = mapped_column(ForeignKey("experiments.exp_id"))
+    experiment = relationship("SqlExperiment", back_populates="runs")
+    device_id = mapped_column(ForeignKey("devices.device_id"))
+    device = relationship("SqlDevice", back_populates="runs")
+    name: Mapped[str] = mapped_column(String)
+
+    setup: Mapped[str] = mapped_column(String)
+
+    ### Data specific to this run
+    result_count: Mapped[int] = mapped_column(Integer, default=0)
+    batch_count: Mapped[int] = mapped_column(Integer, default=0)
+    coords: Mapped[list[str]] = mapped_column(ARRAY(String))
+    sweeps: Mapped[dict[int, list[str]]] = mapped_column(JSONB)
+
+    ### Timestamps and status
+    start_time: Mapped[int] = mapped_column(BigInteger)
+    completed_time: Mapped[int] = mapped_column(
+        BigInteger, default=None, nullable=True)
+    is_completed: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    measurement_exception: Mapped[str] = mapped_column(
+        Text, default=None, nullable=True)
+    parent_datasets: Mapped[list[int]] = mapped_column(
+        ARRAY(Integer), default=None, nullable=True)
+
+class SqlExperiment(Base):
+    __tablename__ = "experiments"
+
+    exp_id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(String, unique=True, nullable=False)
+    creation_time: Mapped[int] = mapped_column(BigInteger)
+    #run_counter: Mapped[int] = mapped_column(Integer)
+    #format_string: Mapped[str] = mapped_column(String)
+
+    runs: Mapped[list[SqlRun]] = relationship(
+        "SqlRun", back_populates="experiment", cascade="all, delete-orphan"
+    )
+
+    __table_args__ = (
+        UniqueConstraint("name", name="uq_experiment_name"),
+    )
+
+    def __repr__(self) -> str:
+        return (f"<Experiment(exp_id={self.exp_id}, name='{self.name}', "
+                f"creation_time={self.creation_time}> ")
+
+class SqlDevice(Base):
+    __tablename__ = "devices"
+
+    device_id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(String, unique=True, nullable=False)
+    runs: Mapped[list[SqlRun]] = relationship("SqlRun", back_populates="device")
+
+    def __repr__(self) -> str:
+        return f"<Device(device_id={self.device_id}, name='{self.name}')>"

arbok_inspector/classes/qcodes_run.py

@@ -0,0 +1,65 @@
+"""Module containing QcodesRun class"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import os
+from pathlib import Path
+
+from qcodes.dataset import load_by_id
+from qcodes.dataset.sqlite.database import get_DB_location
+from arbok_inspector.classes.base_run import BaseRun
+
+if TYPE_CHECKING:
+    from xarray import Dataset
+
+COLUMN_LABELS = {}
+
+class QcodesRun(BaseRun):
+    """"""
+    def __init__(
+            self,
+            run_id: int
+    ):
+        """
+        Constructor for QcodesRun class
+        
+        Args:
+            run_id (int): Run ID of the measurement run
+        """
+        super().__init__(run_id)
+        
+    def _load_dataset(self) -> Dataset:
+        dataset = load_by_id(self.run_id)
+        dataset = dataset.to_xarray_dataset()
+        return dataset
+
+    def _get_database_columns(self) -> dict[str, dict[str, str]]:
+        self.inspector.cursor.execute(
+            "SELECT * FROM runs WHERE run_id = ?", (self.run_id,))
+        row = self.inspector.cursor.fetchone()
+        if row is not None:
+            row_dict = dict(row)
+        else:
+            raise ValueError(f'database entry not found for run-ID: {self.run_id}')
+        columns_and_values = {}
+        for key, value in row_dict.items():
+            columns_and_values[key] = {'value': value}
+            if key in COLUMN_LABELS:
+                label = COLUMN_LABELS[key]
+                columns_and_values[key]['label'] = label
+        return columns_and_values
+
+    def get_qua_code(self, as_string: bool = False) -> str | bytes:
+        db_path = os.path.abspath(get_DB_location())
+        db_dir = os.path.dirname(db_path)
+        programs_dir = Path(db_dir) / "qua_programs/"
+        raise NotImplementedError
+        ### TODO: IMPLEMENT MORE EASILY IN ARBOK THOUGH!
+        # if not os.path.isdir(programs_dir):
+        #     os.makedirs(programs_dir)
+        # try:
+        #     with open(save_path, 'r', encoding="utf-8") as file:
+        #         file.write(
+        #             generate_qua_script(qua_program, opx_config))
+        # except FileNotFoundError as e:
+        #     ui.notify(f"Qua program couldnt be found next to database: {e}")