bindmc 0.1.0__py3-none-any.whl

bindmc/main.py

@@ -0,0 +1,67 @@
+#to build: rm -fr build && rm -fr dist && nicegui-pack --onefile --add-data "C:\Users\mpeeks\miniforge3\envs\binding-nicegui\Lib\site-packages\arviz\static;arviz/static" --add-data "C:\Users\mpeeks\miniforge3\envs\binding-nicegui\Lib\site-packages\arviz\data;arviz/data" --add-data "C:\Users\mpeeks\miniforge3\envs\binding-nicegui\Lib\site-packages\latex2mathml\unimathsymbols.txt;latex2mathml" main.py
+
+# on windows:
+# nicegui-pack main.py --no-build
+
+# macOS packaging support
+from multiprocessing import freeze_support  # noqa
+freeze_support()  # noqa
+
+# hidden import for pyinstaller
+import matplotlib
+matplotlib.use('module://matplotlib.backends.backend_svg')
+import sys
+from nicegui import native,ui,app
+from webgui.app import BindToolsServer
+import logging
+import nicegui
+from packaging.version import InvalidVersion, Version
+from pathlib import Path
+from platformdirs import user_data_dir
+
+logger = logging.getLogger(__name__)
+
+try:
+    nicegui_version = Version(nicegui.__version__)
+except InvalidVersion:
+    logger.warning(
+        "Could not parse NiceGUI version '%s'; continuing, but NiceGUI >= 3 is required.",
+        nicegui.__version__,
+    )
+else:
+    if nicegui_version.is_prerelease or nicegui_version.is_devrelease:
+        logger.warning(
+            "NiceGUI %s is a pre-release/dev build; recommended to install the latest stable 3.x.",
+            nicegui.__version__,
+        )
+    elif nicegui_version.major < 3:
+        raise RuntimeError(f"NiceGUI >= 3 is required; found {nicegui.__version__}")
+
+
+app.native.settings['ALLOW_DOWNLOADS'] = True
+
+#logging.basicConfig(level=logging.INFO, filename='bindtools.log')
+logging.basicConfig(level=logging.INFO, format='%(levelname)s:%(message)s')
+
+logger.info("Starting BindTools NiceGUI server...")
+BindToolsServer()
+
+# Set DEV based on whether running from PyInstaller bundle
+DEV = not getattr(sys, 'frozen', False)
+
+if DEV:
+    native_mode=False
+    reload=True
+else:
+    native_mode=True
+    reload=False
+
+
+# make a sensible storage path for native mode
+storage_path = Path(user_data_dir(appname="BindTools", appauthor=False))
+storage_path.mkdir(parents=True, exist_ok=True)
+
+# Redirect native window persistence data away from default paths
+app.native.start_args['storage_path'] = str(storage_path)
+
+ui.run(title='BindTools', reload=reload, native=native_mode, port=native.find_open_port(), storage_secret='bindtools_secret')

bindmc/webgui/app.py

@@ -0,0 +1,54 @@
+from nicegui import ui
+
+from .components import (
+    BindToolsHeader,
+    Body
+)
+from .state.statemanager import StateManager
+
+class BindToolsServer:
+
+    def __init__(self):
+
+        self.state_manager: StateManager = StateManager(load_prior_state=False)  # Initialize state_manager attribute
+        self.sm: StateManager =self.state_manager
+        self.components = {}
+        self.body_components={}
+        self.tabs = {}
+        self.setup_routes()
+
+
+    def setup_routes(self):
+        """Set up the application routes and UI components."""
+
+        @ui.page("/")
+
+        def index(): 
+            self.state_manager = StateManager()
+            self.sm = self.state_manager  # alias
+            self._generate_header()
+            self._generate_body()
+            self.body_components = self.components["body"].components
+            self._load_prior_state()
+            
+    
+
+    def _load_prior_state(self):
+        # if simulations have been run already, populate the graph
+        if len(self.sm.simulations) > 0:
+            self.body_components["simulation"].graph.load_simulations_data()
+        if self.sm.active_expt_data_id is not None and self.sm.active_expt_data.data is not None and not self.sm.active_expt_data.data.empty:
+            self.sm.notify_listeners("data_imported")
+        if len(self.sm.fits) > 0:
+            self.sm.notify_listeners("fits_loaded")
+            # self.components["fit_results"].sync_graphs()
+            # self.components["fit_results"].generate_delete_fit_dropdown()
+
+        
+    def _generate_header(self):
+        ui.colors(primary='#000000', secondary='grey-5', accent='blue-grey-5')
+
+        self.components["header"] = BindToolsHeader(state_manager=self.state_manager)
+
+    def _generate_body(self):
+        self.components["body"]= Body(self.state_manager)

bindmc/webgui/classes/BindingConstant.py

@@ -0,0 +1,23 @@
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+
+@dataclass
+class BindingConstant:
+    species: str = ""
+    logK: Optional[float] = None
+    vary: bool = False
+    isComp: bool = False
+    min: Optional[float] = None
+    max: Optional[float] = None
+
+    @property
+    def name(self) -> str:
+        return self.species
+
+

bindmc/webgui/classes/ChemicalShiftParam.py

@@ -0,0 +1,40 @@
+
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+
+@dataclass
+class ChemicalShiftParam():
+    """Data class to represent a chemical shift parameter."""
+    species: str = ""
+    col: str | None = None  # raw_data column this resonance/shift belongs to (fast-exchange)
+    value: float | None = None
+    fixed: bool = False  # Whether the parameter is fixed or not
+    _min: float |None = None  # Minimum value for the parameter
+    _max: float |None = None  # Maximum value for the parameter
+
+    init_min: InitVar[Optional[float]] = None  # Initial minimum value for the parameter
+    init_max: InitVar[Optional[float]] = None  # Initial maximum value for
+
+    def __post_init__(self, init_min: Optional[float] = None, init_max: Optional[float] = None) -> None:
+        # if not self.fixed and not isinstance(init_min,float):
+        #     raise ValueError("Variable parameters must have a valid initial minimum value.")
+        # if not self.fixed and not isinstance(init_max,float):
+        #     raise ValueError("Variable parameters must have a valid initial maximum value.")
+        if init_min is not None and init_max is not None and self.value is not None:
+            if init_min >= init_max or init_min>self.value or init_max<self.value:
+                raise ValueError("Initial min and max values must be valid and lesser/greater than the value.")
+        if init_min is None and self._min is not None:
+            return  # No need to set if already defined
+        if init_max is None and self._max is not None:
+            return  # No need to set if already defined
+        self._min = init_min 
+        self._max = init_max 
+        # else:
+        #     raise ValueError("Initial min and max values must be provided for variable parameters.")
+

bindmc/webgui/classes/Component.py

@@ -0,0 +1,111 @@
+import uuid
+from dataclasses import asdict, dataclass, field, InitVar
+from typing import  Optional,Any
+import unicodedata
+from nicegui import binding
+import numpy as np
+import pandas as pd
+from lmfit import Parameter as LMFitParameter
+
+@dataclass
+class Component:
+    name: str = ""
+    start_conc: float|None = 0
+    end_conc: float|None = 0
+    constant: bool = False
+    _start_units: str = "mM"
+    _end_units: str = "mM"
+    spacing: str = "lin"  # 'lin' or 'log', default is linear spacing
+
+    UNIT_CONVERSIONS = {
+        "M": 1,
+        "mM": 1e3,
+        "μM": 1e6,
+        "µM": 1e6,
+        "uM": 1e6,  # support ASCII 'u'
+        "nM": 1e9,
+        "pM": 1e12,
+    }
+
+    @property
+    def start_conc_nice(self) -> float | None:
+        """Get start concentration in the specified units (user-friendly)."""
+        factor = self.UNIT_CONVERSIONS.get(self.start_units, 1)
+        return self.start_conc * factor if self.start_conc is not None else None
+
+    @start_conc_nice.setter
+    def start_conc_nice(self, value: float):
+        """Set start concentration from user-friendly units to base units (M)."""
+        factor = self.UNIT_CONVERSIONS.get(self.start_units, 1)
+        self.start_conc = value / factor if value is not None else None
+
+    @property
+    def end_conc_nice(self) -> float|None:
+        """Get end concentration in the specified units (user-friendly)."""
+        factor = self.UNIT_CONVERSIONS.get(self.end_units, 1)
+        return self.end_conc * factor if self.end_conc is not None else None
+
+    @end_conc_nice.setter
+    def end_conc_nice(self, value: float):
+        """Set end concentration from user-friendly units to base units (M)."""
+        factor = self.UNIT_CONVERSIONS.get(self.end_units, 1)
+        self.end_conc = value / factor if value is not None else None
+
+    @property
+    def start_units(self) -> str:
+        """Get the start concentration units."""
+        return self._start_units
+
+    @start_units.setter
+    def start_units(self, value: str):
+        """Set the start concentration units and recalculate start_conc."""
+        oldunits = self._start_units
+        convfactor = self.UNIT_CONVERSIONS.get(value, 1) / self.UNIT_CONVERSIONS.get(
+            oldunits, 1
+        )
+        self._start_units = value
+
+        self.start_conc = (
+            self.start_conc / convfactor if self.start_conc is not None else None
+        )
+
+    @property
+    def end_units(self) -> str:
+        """Get the end concentration units."""
+        return self._end_units
+
+    @end_units.setter
+    def end_units(self, value: str):
+        """Set the end concentration units and recalculate end."""
+        oldunits = self._end_units
+        convfactor = self.UNIT_CONVERSIONS.get(value, 1) / self.UNIT_CONVERSIONS.get(
+            oldunits, 1
+        )
+        self._end_units = value
+
+        self.end_conc = (
+            self.end_conc / convfactor if self.end_conc is not None else None
+        )
+
+    # """Class to represent a component in the simulation."""
+    # def __init__(self, name, start_conc=None, end_conc=None, constant=False, start_unit='mM', end_unit='mM'):
+
+    #     self.name = name
+    #     self.start_conc = start_conc
+    #     self.end_conc = end_conc
+    #     self.constant = constant
+    #     self.start_unit = start_unit
+    #     self.end_unit = end_unit
+
+    # def to_dict(self):
+    #     """Convert Component to a dictionary."""
+    #     return {
+    #         'name': self.name,
+    #         'start_conc': self.start_conc,
+    #         'end_conc': self.end_conc,
+    #         'constant': self.constant,
+    #         'start_unit': self.start_unit,
+    #         'end_unit': self.end_unit
+    #     }
+
+