AMS-BP 0.4.31__py3-none-any.whl → 0.4.41__py3-none-any.whl

AMS_BP/__init__.py

@@ -10,4 +10,4 @@ Last updated: 2024-12-16
 
 """
 
-__version__ = "0.4.31"
+__version__ = "0.4.41"

AMS_BP/{configio → core/configio}/experiments.py

@@ -20,6 +20,7 @@ class TimeSeriesExpConfig(BaseExpConfig):
     laser_powers_active: List[float]
     laser_positions_active: List
     xyoffset: Tuple[float, float]
+    scanning: bool = False
 
     exposure_time: Optional[int] = None
     interval_time: Optional[int] = None
@@ -61,6 +62,8 @@ class zStackExpConfig(BaseExpConfig):
     exposure_time: int
     interval_time: int
 
+    scanning: bool = False
+
     def __post_init__(self):
         len_ln = len(self.laser_names_active)
         len_lpow = len(self.laser_powers_active)
@@ -94,6 +97,7 @@ def timeseriesEXP(
         duration_total=config.duration_time,
         exposure_time=config.exposure_time,
         interval_time=config.interval_time,
+        scanning=config.scanning,
     )
     return np.array([frames]), metadata
 
@@ -112,6 +116,7 @@ def zseriesEXP(
             duration_total=config.exposure_time + config.interval_time,
             exposure_time=config.exposure_time,
             interval_time=config.interval_time,
+            scanning=config.scanning,
         )
         frames.append(f)
     # m.Channel = {"name": microscope.channels.names}

AMS_BP/{motion → core/motion}/condensate_movement.py

@@ -25,8 +25,8 @@ from typing import Optional
 
 import numpy as np
 
+from ...utils.decorators import cache
 from ..cells import BaseCell
-from ..utils.decorators import cache
 from .track_gen import Track_generator
 
 

AMS_BP/{motion → core/motion}/movement/boundary_conditions.py

@@ -5,7 +5,7 @@ Removal Time: NDY (not determined yet)
 
 import numpy as np
 
-from ...utils.decorators import _catch_recursion_error, deprecated
+from ....utils.decorators import _catch_recursion_error, deprecated
 
 # Reflecting boundary condition which is a recursive function so that even if the first candidate
 # is out of the space limit, the function will keep calling itself until the candidate is within the space limit

AMS_BP/{photophysics → core/photophysics}/photon_physics.py

@@ -3,6 +3,7 @@ from typing import Callable, List, Optional, Tuple
 
 import numpy as np
 
+from ...utils.constants import H_C_COM
 from ..optics.camera.detectors import photon_noise
 from ..optics.camera.quantum_eff import QuantumEfficiency
 from ..optics.filters.filters import FilterSpectrum
@@ -11,7 +12,6 @@ from ..sample.flurophores.flurophore_schema import (
     SpectralData,
     WavelengthDependentProperty,
 )
-from ..utils.constants import H_C_COM
 
 
 @dataclass

AMS_BP/{sample → core/sample}/flurophores/flurophore_schema.py

@@ -4,7 +4,7 @@ from typing import Any, Callable, Dict, List, Optional, TypeVar
 import numpy as np
 from pydantic import BaseModel, Field, field_validator
 
-from ...utils.constants import H_C_COM, N_A
+from ....utils.constants import H_C_COM, N_A
 
 NumericType = TypeVar("NumericType", float, np.ndarray, List[float])
 

AMS_BP/{sim_microscopy.py → core/sim_microscopy.py}

@@ -3,6 +3,7 @@ from typing import Callable, Dict, List, Literal, Optional, Tuple, Union
 
 import numpy as np
 
+from ..utils.util_functions import ms_to_seconds
 from .configio.configmodels import ConfigList
 from .metadata.metadata import MetaData
 from .optics.camera.detectors import Detector
@@ -18,7 +19,6 @@ from .photophysics.photon_physics import (
 from .photophysics.state_kinetics import StateTransitionCalculator
 from .sample.flurophores.flurophore_schema import StateType, WavelengthDependentProperty
 from .sample.sim_sampleplane import EMPTY_STATE_HISTORY_DICT, SamplePlane
-from .utils.util_functions import ms_to_seconds
 
 
 class VirtualMicroscope:

AMS_BP/gui/main.py

@@ -18,12 +18,12 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
-from ..logging.logutil import LoggerManager
-from ..logging.setup_run_directory import setup_run_directory
-from .logging_window import LogWindow
+from ..tools.logging.logutil import LoggerManager
+from ..tools.logging.setup_run_directory import setup_run_directory
 from .sim_worker import SimulationWorker
-from .template_window_selection import TemplateSelectionWindow
 from .widgets.utility_widgets.toggleswitch_widget import ToggleSwitch
+from .windows.logging_window import LogWindow
+from .windows.template_window_selection import TemplateSelectionWindow
 
 LOGO_PATH = str(Path(__file__).parent / "assets" / "drawing.svg")
 

AMS_BP/gui/sim_worker.py

@@ -2,7 +2,9 @@ from pathlib import Path
 
 from PyQt6.QtCore import QObject, pyqtSignal
 
-from ..logging.logutil import LogEmitter
+from ..core.configio.convertconfig import load_config, setup_microscope
+from ..core.configio.saving import save_config_frames
+from ..tools.logging.logutil import LogEmitter
 
 
 class SimulationWorker(QObject):
@@ -20,9 +22,6 @@ class SimulationWorker(QObject):
         try:
             self.emitter.message.emit(f"Starting simulation for {self.config_path}")
 
-            from ..configio.convertconfig import load_config, setup_microscope
-            from ..configio.saving import save_config_frames
-
             loadedconfig = load_config(self.config_path)
 
             if "version" in loadedconfig:

AMS_BP/gui/widgets/camera_config_widget.py

@@ -14,6 +14,10 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_quantum_efficiency_from_config
+from ...core.optics.camera.detectors import (
+    CMOSDetector,
+)
 from .utility_widgets.spectrum_widget import SpectrumEditorDialog
 
 
@@ -122,11 +126,6 @@ class CameraConfigWidget(QWidget):
             # You can now use this data wherever needed, e.g., saving or validation
 
     def validate(self) -> bool:
-        from ...configio.convertconfig import create_quantum_efficiency_from_config
-        from ...optics.camera.detectors import (
-            CMOSDetector,
-        )
-
         try:
             data = self.get_data()
 

AMS_BP/gui/widgets/cell_config_widget.py

@@ -14,6 +14,9 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.cells import create_cell
+from ...core.configio.configmodels import CellParameters
+
 
 class CellConfigWidget(QWidget):
     def __init__(self):
@@ -53,9 +56,6 @@ class CellConfigWidget(QWidget):
         layout.addWidget(self.validate_button)
 
     def validate(self) -> bool:
-        from ...cells import create_cell
-        from ...configio.configmodels import CellParameters
-
         try:
             data = self.get_data()
 

AMS_BP/gui/widgets/channel_config_widget.py

@@ -15,6 +15,8 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_channels
+
 
 class ChannelConfigWidget(QWidget):
     def __init__(self):
@@ -48,8 +50,6 @@ class ChannelConfigWidget(QWidget):
 
     def validate(self) -> bool:
         try:
-            from ...configio.convertconfig import create_channels
-
             data = self.get_data()
 
             # Full simulation-level validation

AMS_BP/gui/widgets/condensate_config_widget.py

@@ -18,6 +18,10 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.cells import create_cell
+from ...core.configio.configmodels import CondensateParameters
+from ...core.motion import create_condensate_dict
+
 
 class CondensateConfigWidget(QWidget):
     # Signal to notify when molecule count changes
@@ -300,10 +304,6 @@ class CondensateConfigWidget(QWidget):
         }
 
     def validate(self) -> bool:
-        from ...cells import create_cell
-        from ...configio.configmodels import CondensateParameters
-        from ...motion import create_condensate_dict
-
         try:
             data = self.get_data()
 

AMS_BP/gui/widgets/experiment_config_widget.py

@@ -1,10 +1,12 @@
 from pathlib import Path
 from typing import List
 
+from PyQt6.QtCore import Qt, QTimer
 from PyQt6.QtWidgets import (
     QComboBox,
     QDoubleSpinBox,
     QFormLayout,
+    QGraphicsOpacityEffect,
     QHBoxLayout,
     QLabel,
     QLineEdit,
@@ -18,6 +20,8 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_experiment_from_config
+
 
 class ExperimentConfigWidget(QWidget):
     def __init__(self):
@@ -31,6 +35,32 @@ class ExperimentConfigWidget(QWidget):
         layout.setSpacing(10)
         self.setLayout(layout)
         self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+        self.scanning_area = QWidget()
+        self.scanning_area_layout = QVBoxLayout()
+        self.scanning_area_layout.setContentsMargins(0, 0, 0, 0)
+        self.scanning_area_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.scanning_area.setLayout(self.scanning_area_layout)
+        layout.addWidget(self.scanning_area)
+        # Setup scanning label
+        self.scanning_label = QLabel("Scanning Confocal Selected")
+        self.scanning_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.scanning_label.setStyleSheet(
+            "color: green; font-weight: bold; font-size: 16px;"
+        )
+        layout.addWidget(self.scanning_label)
+        # Reserve space by always having label active, even if invisible
+        self.opacity_effect = QGraphicsOpacityEffect(self.scanning_label)
+        self.scanning_label.setGraphicsEffect(self.opacity_effect)
+        self.opacity_effect.setOpacity(0.0)  # start invisible but reserved
+
+        # Blinking mode control
+        self._scanning_mode = False
+        self._blinking = False
+        self.blink_timer = QTimer(self)
+        self.blink_timer.setInterval(500)  # ms
+        self.blink_timer.timeout.connect(self._toggle_scanning_label_visibility)
+
         form = QFormLayout()
 
         # Experiment Info
@@ -103,6 +133,24 @@ class ExperimentConfigWidget(QWidget):
         self.validate_button.clicked.connect(self.validate)
         layout.addWidget(self.validate_button)
 
+    def set_scanning_mode(self, enabled: bool):
+        self._scanning_mode = enabled
+        if enabled:
+            self.opacity_effect.setOpacity(1.0)
+            self.blink_timer.start()
+        else:
+            self.opacity_effect.setOpacity(0.0)
+            self.blink_timer.stop()
+
+    def _toggle_scanning_label_visibility(self):
+        """Toggles label opacity to create blinking without layout shifting."""
+        if self._scanning_mode:
+            current_opacity = self.opacity_effect.opacity()
+            new_opacity = 0.0 if current_opacity > 0.5 else 1.0
+            self.opacity_effect.setOpacity(new_opacity)
+        else:
+            self.opacity_effect.setOpacity(0.0)
+
     def update_z_position_mode(self, mode: str):
         # Clear existing
         for i in reversed(range(self.z_position_layout.count())):
@@ -202,6 +250,7 @@ class ExperimentConfigWidget(QWidget):
                 for name in self.laser_position_widgets
             ],
             "xyoffset": [w.value() for w in self.xyoffset],
+            "scanning": self._scanning_mode,
         }
 
         if data["experiment_type"] == "z-stack":
@@ -249,10 +298,12 @@ class ExperimentConfigWidget(QWidget):
         positions = data.get("laser_positions_active", [])
         self.set_active_lasers(laser_names, powers=powers, positions=positions)
 
+        # Scanning Confocal
+        scanning_mode = data.get("scanning", False)
+        self.set_scanning_mode(scanning_mode)
+
     def validate(self) -> bool:
         try:
-            from ...configio.convertconfig import create_experiment_from_config
-
             data = self.get_data()
             config_dict = {"experiment": data}
 

AMS_BP/gui/widgets/flurophore_config_widget.py

@@ -18,6 +18,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_fluorophores_from_config
 from .utility_widgets.scinotation_widget import scientific_input_field
 from .utility_widgets.spectrum_widget import SpectrumEditorDialog
 
@@ -495,8 +496,6 @@ class FluorophoreConfigWidget(QWidget):
 
     def validate(self) -> bool:
         try:
-            from ...configio.convertconfig import create_fluorophores_from_config
-
             data = self.get_data()
             # Try to build fluorophores with the backend logic
 

AMS_BP/gui/widgets/global_config_widget.py

@@ -11,6 +11,8 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.configio.configmodels import GlobalParameters
+
 
 class GlobalConfigWidget(QWidget):
     def __init__(self):
@@ -122,8 +124,6 @@ class GlobalConfigWidget(QWidget):
 
     def validate(self) -> bool:
         try:
-            from ...configio.configmodels import GlobalParameters
-
             data = self.get_data()
 
             GlobalParameters(**data)

AMS_BP/gui/widgets/laser_config_widget.py

@@ -1,10 +1,12 @@
 from pathlib import Path
 
-from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtCore import Qt, QTimer, pyqtSignal
 from PyQt6.QtWidgets import (
     QComboBox,
     QDoubleSpinBox,
     QFormLayout,
+    QGraphicsOpacityEffect,
+    QLabel,
     QLineEdit,
     QMessageBox,
     QPushButton,
@@ -15,12 +17,15 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_lasers_from_config
+
 
 class LaserConfigWidget(QWidget):
     laser_names_updated = pyqtSignal(list)
 
     def __init__(self):
         super().__init__()
+        self._confocal_mode = False
         self.laser_name_widgets = []
         layout = QVBoxLayout()
         layout.setContentsMargins(10, 10, 10, 10)
@@ -28,6 +33,25 @@ class LaserConfigWidget(QWidget):
         self.setLayout(layout)
         self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
 
+        self.scanning_label = QLabel(
+            "Scanning Confocal Selected \n Only Gaussian Laser Allowed"
+        )
+        self.scanning_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.scanning_label.setStyleSheet(
+            "color: green; font-weight: bold; font-size: 14px;"
+        )
+        self.scanning_label.setVisible(
+            True
+        )  # Always visible — will control opacity instead
+        # blinking effect
+        self.opacity_effect = QGraphicsOpacityEffect(self.scanning_label)
+        self.scanning_label.setGraphicsEffect(self.opacity_effect)
+        self.opacity_effect.setOpacity(0.0)
+        self.blink_timer = QTimer(self)
+        self.blink_timer.setInterval(500)
+        self.blink_timer.timeout.connect(self._toggle_scanning_label_opacity)
+        layout.addWidget(self.scanning_label)
+
         form = QFormLayout()
 
         self.num_lasers = QSpinBox()
@@ -50,39 +74,51 @@ class LaserConfigWidget(QWidget):
         self.validate_button.clicked.connect(self.validate)
         layout.addWidget(self.validate_button)
 
+    def _toggle_scanning_label_opacity(self):
+        if self._confocal_mode:
+            current_opacity = self.opacity_effect.opacity()
+            new_opacity = 0.0 if current_opacity > 0.5 else 1.0
+            self.opacity_effect.setOpacity(new_opacity)
+        else:
+            self.opacity_effect.setOpacity(0.0)
+
     def set_confocal_mode(self, enabled: bool):
+        self._confocal_mode = enabled
+
         for i in range(self.laser_tabs.count()):
             tab = self.laser_tabs.widget(i)
 
             laser_type: QComboBox = tab.findChild(QComboBox)
             beam_width: QDoubleSpinBox = tab.findChildren(QDoubleSpinBox)[
                 1
-            ]  # Assumes 2nd spinbox is beam_width
+            ]  # second spinbox is beam_width
 
             if enabled:
-                # Force laser type to "gaussian" and disable editing
                 laser_type.setCurrentText("gaussian")
                 laser_type.setEnabled(False)
 
-                # Hide beam width
                 beam_width.hide()
                 label = tab.layout().labelForField(beam_width)
                 if label:
                     label.hide()
             else:
-                # Enable laser type editing
                 laser_type.setEnabled(True)
 
-                # Show beam width
                 beam_width.show()
                 label = tab.layout().labelForField(beam_width)
                 if label:
                     label.show()
 
+        # Handle blinking label
+        if enabled:
+            self.scanning_label.setVisible(True)
+            self.blink_timer.start()
+        else:
+            self.scanning_label.setVisible(False)
+            self.blink_timer.stop()
+
     def validate(self) -> bool:
         try:
-            from ...configio.convertconfig import create_lasers_from_config
-
             data = self.get_data()
             create_lasers_from_config({"lasers": data})
 
@@ -148,13 +184,22 @@ class LaserConfigWidget(QWidget):
         layout.addRow(f"Laser {index + 1} Beam Width (µm):", beam_width)
         layout.addRow(f"Laser {index + 1} Numerical Aperture:", numerical_aperture)
         layout.addRow(f"Laser {index + 1} Refractive Index:", refractive_index)
-        layout.addRow(f"Laser {index + 1} Inclination Angle (°):", inclination_angle)
+        inclination_label = QLabel(f"Laser {index + 1} Inclination Angle (°):")
+        layout.addRow(inclination_label, inclination_angle)
 
         # Logic for hilo
-        laser_type.currentTextChanged.connect(
-            lambda val: inclination_angle.setEnabled(val == "hilo")
-        )
-        inclination_angle.setEnabled(laser_type.currentText() == "hilo")
+        def handle_inclination_visibility(selected_type):
+            if selected_type == "hilo":
+                inclination_angle.show()
+                inclination_label.show()
+            else:
+                inclination_angle.hide()
+                inclination_label.hide()
+
+        laser_type.currentTextChanged.connect(handle_inclination_visibility)
+
+        # Initial state
+        handle_inclination_visibility(laser_type.currentText())
 
         tab.setLayout(layout)
         self.laser_tabs.addTab(tab, f"Laser {index + 1}")

AMS_BP/gui/widgets/molecule_config_widget.py

@@ -20,6 +20,9 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ...core.configio.configmodels import MoleculeParameters
+from ...core.configio.convertconfig import create_dataclass_schema
+
 
 class MoleculeConfigWidget(QWidget):
     # Signal to notify when molecule count changes
@@ -99,8 +102,6 @@ class MoleculeConfigWidget(QWidget):
             data = self.get_data()
 
             # This will validate the schema using the backend logic
-            from ...configio.configmodels import MoleculeParameters
-            from ...configio.convertconfig import create_dataclass_schema
 
             _ = create_dataclass_schema(MoleculeParameters, data)
 
@@ -120,10 +121,6 @@ class MoleculeConfigWidget(QWidget):
         Load molecule configuration from TOML config format.
         """
         try:
-            # Validate format first
-            from ...configio.configmodels import MoleculeParameters
-            from ...configio.convertconfig import create_dataclass_schema
-
             validated = create_dataclass_schema(MoleculeParameters, config)
 
             # Determine number of types

AMS_BP/gui/{configuration_window.py → windows/configuration_window.py}

@@ -18,19 +18,19 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ..widgets.camera_config_widget import CameraConfigWidget
+from ..widgets.cell_config_widget import CellConfigWidget
+from ..widgets.channel_config_widget import ChannelConfigWidget
+from ..widgets.condensate_config_widget import CondensateConfigWidget
+from ..widgets.experiment_config_widget import ExperimentConfigWidget
+from ..widgets.flurophore_config_widget import FluorophoreConfigWidget
+from ..widgets.general_config_widget import GeneralConfigWidget
+from ..widgets.global_config_widget import GlobalConfigWidget
+from ..widgets.laser_config_widget import LaserConfigWidget
+from ..widgets.molecule_config_widget import MoleculeConfigWidget
+from ..widgets.output_config_widget import OutputConfigWidget
+from ..widgets.psf_config_widget import PSFConfigWidget
 from .help_window import HelpWindow
-from .widgets.camera_config_widget import CameraConfigWidget
-from .widgets.cell_config_widget import CellConfigWidget
-from .widgets.channel_config_widget import ChannelConfigWidget
-from .widgets.condensate_config_widget import CondensateConfigWidget
-from .widgets.experiment_config_widget import ExperimentConfigWidget
-from .widgets.flurophore_config_widget import FluorophoreConfigWidget
-from .widgets.general_config_widget import GeneralConfigWidget
-from .widgets.global_config_widget import GlobalConfigWidget
-from .widgets.laser_config_widget import LaserConfigWidget
-from .widgets.molecule_config_widget import MoleculeConfigWidget
-from .widgets.output_config_widget import OutputConfigWidget
-from .widgets.psf_config_widget import PSFConfigWidget
 
 
 class ConfigEditor(QWidget):
@@ -110,6 +110,9 @@ class ConfigEditor(QWidget):
 
         # === Widget interconnections ===
         self.psf_tab.confocal_mode_changed.connect(self.laser_tab.set_confocal_mode)
+        self.psf_tab.confocal_mode_changed.connect(
+            self.experiment_tab.set_scanning_mode
+        )
 
         self.molecule_tab.molecule_count_changed.connect(
             self.fluorophore_tab.set_mfluorophore_count

AMS_BP/gui/{template_window_selection.py → windows/template_window_selection.py}

@@ -11,13 +11,14 @@ from PyQt6.QtWidgets import (
     QMessageBox,
     QPushButton,
     QScrollArea,
+    QSizePolicy,
     QVBoxLayout,
     QWidget,
 )
 
 from .configuration_window import ConfigEditor
 
-TEMPLATE_DIR = Path(__file__).parent.parent / "resources" / "template_configs"
+TEMPLATE_DIR = Path(__file__).parent.parent.parent / "resources" / "template_configs"
 METADATA_PATH = TEMPLATE_DIR / "metadata_configs.json"
 
 
@@ -52,32 +53,61 @@ class TemplateSelectionWindow(QWidget):
 
     def create_template_card(self, entry: dict) -> QWidget:
         group = QGroupBox(entry["label"])
+        group.setMinimumHeight(150)
+        group.setMaximumHeight(200)
         layout = QHBoxLayout()
+        layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        layout.setSpacing(15)
 
         # Image
         img_label = QLabel()
         img_path = TEMPLATE_DIR / entry["image"]
         if img_path.exists():
             pixmap = QPixmap(str(img_path)).scaled(
-                200, 200, Qt.AspectRatioMode.KeepAspectRatio
+                150,
+                150,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
             )
             img_label.setPixmap(pixmap)
         else:
             img_label.setText("[Missing image assets]")
+        img_label.setFixedSize(150, 150)
+        img_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         layout.addWidget(img_label)
 
-        # Description + Button
+        # Description + Button (in a VBox)
         vbox = QVBoxLayout()
+        vbox.setAlignment(Qt.AlignmentFlag.AlignTop)
+
+        # Scrollable description
+        desc_scroll = QScrollArea()
+        desc_scroll.setFixedHeight(100)  # Height for the scroll area
+        desc_scroll.setWidgetResizable(True)
+
+        desc_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        desc_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 
         description_label = QLabel(entry.get("description", ""))
-        description_label.setWordWrap(True)  # <--- this is the key!
-        vbox.addWidget(description_label)
+        description_label.setWordWrap(True)
+        description_label.setAlignment(
+            Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft
+        )
+        description_label.setContentsMargins(5, 5, 5, 5)
+        description_label.setSizePolicy(
+            description_label.sizePolicy().horizontalPolicy(),
+            QSizePolicy.Policy.Maximum,
+        )
+
+        desc_scroll.setWidget(description_label)
+        vbox.addWidget(desc_scroll)
 
         btn = QPushButton("Use This Template")
         btn.clicked.connect(
             lambda _, config=entry["config"]: self.load_template(config)
         )
         vbox.addWidget(btn)
+
         layout.addLayout(vbox)
 
         group.setLayout(layout)

AMS_BP/main_cli.py

@@ -34,9 +34,9 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from typing_extensions import Annotated
 
 from . import __version__
+from .core.run_sim_util import run_simulation_from_file
 from .gui.main import MainWindow
-from .logging.logutil import cleanup_old_logs
-from .run_sim_util import run_simulation_from_file
+from .tools.logging.logutil import cleanup_old_logs
 
 cli_help_doc = str(
     """