pykrait 0.2.4__tar.gz → 0.3.1__tar.gz

{pykrait-0.2.4 → pykrait-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pykrait
-Version: 0.2.4
+Version: 0.3.1
 Summary: Python Calcium Recording Analysis and Inference Toolbox
 Author-email: phaleanopsis <22663502+phaleanopsis@users.noreply.github.com>
 License: MIT
@@ -28,8 +28,10 @@ Requires-Dist: pydantic<2
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: resource-backed-dask-array>=0.1.0
 Requires-Dist: scikit-image>=0.25.2
+Requires-Dist: scikit-learn>=1.7.2
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: xarray>2025
+Requires-Dist: zstandard>=0.23.0
 Provides-Extra: dev
 Requires-Dist: build>=1.2.2.post1; extra == 'dev'
 Requires-Dist: hatch>=1.14.1; extra == 'dev'

{pykrait-0.2.4 → pykrait-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pykrait"
-version = "0.2.4"
+version = "0.3.1"
 description = "Python Calcium Recording Analysis and Inference Toolbox"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }
@@ -33,6 +33,8 @@ dependencies = [
     "scipy>=1.15.3",
     "xarray>2025",
     "pandas>=2.3.1",
+    "zstandard>=0.23.0",
+    "scikit-learn>=1.7.2",
 ]
 
 [project.optional-dependencies]
@@ -68,6 +70,17 @@ packages = ["src/pykrait"]
 [tool.hatch.build.targets.sdist]
 include = ["src/**", "README.md", "pyproject.toml"]
 
+[tool.hatch.envs.tests]
+dependencies = [
+  "pytest",
+  "pytest-cov",
+]
+
+[tool.hatch.envs.coverage]
+dependencies = [
+  "coverage[toml]",
+]
+
 [tool.pytest.ini_options]
 pythonpath = ["src"]
 testpaths = ["tests"]
@@ -85,4 +98,4 @@ skip_covered = true
 [tool.ruff]
 src = ["src"]
 line-length = 88
-target-version = "py311"
+target-version = "py311"

{pykrait-0.2.4 → pykrait-0.3.1}/src/pykrait/__main__.py

@@ -1,6 +1,7 @@
 """
 Copyright © 2025 Pentabyteman
 """
+
 # src/pykrait/__main__.py
 from pykrait.gui.app import AppController
 

{pykrait-0.2.4 → pykrait-0.3.1}/src/pykrait/gui/app.py

@@ -1,23 +1,41 @@
 import sys
 import os
+import warnings
 from PySide6.QtCore import QSize
 from PySide6.QtGui import QIcon
 from PySide6.QtWidgets import QApplication
 from pykrait.gui.fileselection import FileSelectionWindow
 from pykrait.gui.mainwindow import MainWindow
+from pykrait.io.files import get_pykrait_version
+
+def warning_no_source_line(message, category, filename, lineno, file=None, line=None):
+    return f"{filename}:{lineno}: {category.__name__}: {message}\n"
 
 class AppController:
     def __init__(self):
+
+        # format warnings to not print the source line every time
+        warnings.formatwarning = warning_no_source_line
+        
         self.app = QApplication(sys.argv)
 
         # Loading icon from resources
         appIcon = QIcon()
         try:
             from importlib.resources import files
+
             icon_path = files("pykrait.gui.resources").joinpath("logo.png")
             os.path.exists(icon_path)
         except Exception:
-            icon_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "pykrait/gui/resources", "logo.png"))
+            icon_path = os.path.abspath(
+                os.path.join(
+                    os.path.dirname(__file__),
+                    "..",
+                    "..",
+                    "pykrait/gui/resources",
+                    "logo.png",
+                )
+            )
             os.path.exists(icon_path)
         if os.path.exists(icon_path):
             appIcon.addFile(str(icon_path), QSize(16, 16))
@@ -32,10 +50,17 @@ class AppController:
 
         # Set application name and version
         self.app.setApplicationName("pyKrait")
-        self.app.setApplicationVersion("0.2.1")  
+        version = get_pykrait_version()
+        if version is not None:
+            self.app.setApplicationVersion(version)
         self.file_selection = FileSelectionWindow()
         self.file_selection.analysis_complete.connect(self.on_analysis_complete)
         self.file_selection.show()
+        
+        #updating the style
+        self.app.setStyle("Fusion")
+        light_palette = self.app.style().standardPalette()
+        self.app.setPalette(light_palette)
 
         # Keep references to windows
         self.main_window = None
@@ -52,7 +77,7 @@ class AppController:
             mean_intensities=results["mean_intensities"],
             analysis_output=results["analysis_output"],
             analysis_params=results["analysis_parameters"],
-            app_controller=self
+            app_controller=self,
         )
         self.main_window.show()
 
@@ -66,4 +91,4 @@ class AppController:
 
         self.file_selection = FileSelectionWindow()
         self.file_selection.analysis_complete.connect(self.on_analysis_complete)
-        self.file_selection.show()
+        self.file_selection.show()

pykrait-0.3.1/src/pykrait/gui/async_workers.py

@@ -0,0 +1,323 @@
+from PySide6.QtCore import QObject, Signal, Slot
+import traceback
+import numpy as np
+from pykrait.io.images import read_label_image, get_pixel_contour_from_label_img
+from pykrait.io.files import read_Txnrois
+from pykrait.preprocessing.segmentation import timelapse_projection
+import tifffile
+from pykrait.preprocessing.timeseries_extraction import extract_mean_intensities, get_adjacency_matrix
+from pykrait.trace_analysis.filtering import detrend_with_sinc_filter
+import os
+
+from pykrait.pipeline.pipeline import (
+    AnalysisParameters,
+    AnalysisOutput,
+    create_analysis_folder,
+    load_timelapse,
+    create_masks,
+    do_peak_analysis,
+    calculate_periodic_cells,
+    calculate_synchronicity,
+    save_analysis_results,
+    save_params
+)
+
+class ExtractIntensitiesWorker(QObject):
+    """
+    Worker for extracting mean intensities from a timelapse dataset, using either Cellpose segmentation or a label image.
+    """
+
+    progress_changed = Signal(int, str)  # progress percent, status message
+    finished = Signal(dict)  # analysis results
+    error = Signal(str)  # error message
+
+    def __init__(
+        self,
+        analysis_params: AnalysisParameters,
+        output_params: AnalysisOutput,
+        mode: str,
+        mean_intensities_path: str = None,
+    ):
+        super().__init__()
+        self.analysis_parameters = analysis_params
+        self.analysis_output = output_params
+        self.mode = mode
+        self.mean_intensities_path = mean_intensities_path
+
+    @Slot()
+    def run(self):
+        try:
+            self.analysis_output = create_analysis_folder(self.analysis_output)
+            print(f"Running analysis on {self.analysis_output.filename}")
+            # loading the timelapse data and analysing frame interval
+            self.timelapse_data, self.analysis_output = load_timelapse(
+                self.analysis_output, self.analysis_parameters
+            )
+
+            if self.mode == "cellpose":
+                # perform the tproj
+                self.progress_changed.emit(
+                    10, "Performing T Projection and Cellpose Segmentation..."
+                )
+                # creating the masks and saving them to the analysis folder
+                _, _, self.masks, self.analysis_output = create_masks(
+                    self.timelapse_data, self.analysis_output, self.analysis_parameters
+                )
+                # extracts the mean intensities of the masks
+                self.progress_changed.emit(60, "Extracting intensities...")
+                mean_intensities = extract_mean_intensities(
+                    self.timelapse_data, self.masks
+                )
+            elif self.mode == "label_image":
+                if self.analysis_output.tproj_path is None:
+                    print("Performing T Projection...")
+                    tproj = timelapse_projection(
+                        self.timelapse_data,
+                        method="std",
+                        normalize=True,
+                        verbose=True,
+                    )
+
+                    filename_wo_ext = os.path.splitext(self.analysis_output.filename)[0]
+                    self.analysis_output.tproj_path = os.path.join(
+                        self.analysis_output.analysis_folder, f"{filename_wo_ext}_tproj.ome.tif"
+                    )
+                    tifffile.imwrite(
+                        self.analysis_output.tproj_path,
+                        tproj.astype(np.uint16),
+                        metadata={"axes": "CYX"},
+                        compression="zlib",
+                    )
+                self.progress_changed.emit(20, "Loading label image...")
+                self.masks = read_label_image(self.analysis_output.masks_path)
+                # extracts the mean intensities of the masks
+                self.progress_changed.emit(60, "Extracting intensities...")
+                mean_intensities = extract_mean_intensities(
+                    self.timelapse_data, self.masks
+                )
+            elif self.mode == "csv":
+                self.progress_changed.emit(20, "Loading label image...")
+                self.masks = read_label_image(self.analysis_output.masks_path)
+                self.progress_changed.emit(60, "Reading intensities...")
+                mean_intensities = read_Txnrois(
+                    self.mean_intensities_path,
+                    n_frames=self.timelapse_data.shape[0],
+                    n_rois=self.masks.max(),
+                )
+            else:
+                raise ValueError("Unknown mode.")
+
+            (
+                self.analysis_output.number_of_frames,
+                self.analysis_output.number_of_cells,
+            ) = mean_intensities.shape
+
+            # All done
+            self.progress_changed.emit(90, "Calculating ROI boundaries...")
+            rois = get_pixel_contour_from_label_img(
+                self.masks, orig_shape=self.masks.shape, target_shape=(512, 512)
+            )
+
+            self.progress_changed.emit(100, "Done.")
+
+            results = {
+                "frames": self.timelapse_data,
+                "analysis_output": self.analysis_output,
+                "analysis_parameters": self.analysis_parameters,
+                "masks": self.masks,
+                "rois": rois,
+                "mean_intensities": mean_intensities,
+            }
+            save_params(self.analysis_output, self.analysis_parameters, overwrite=True)
+            self.finished.emit(results)
+
+        except Exception as e:
+            tb = traceback.format_exc()
+            print(f"Error during analysis: {e}\n{tb}")
+            self.error.emit(str(e))
+
+
+class DetrendWorker(QObject):
+    """
+    _summary_
+
+    :param QObject: _description_
+    :type QObject: _type_
+    """
+
+    finished = Signal(np.ndarray)
+    error = Signal(Exception)
+
+    def __init__(self, intensities, sinc_window, frame_interval):
+        super().__init__()
+        self.intensities = intensities
+        self.sinc_window = sinc_window
+        self.frame_interval = frame_interval
+
+    def run(self):
+        try:
+            # Call your actual function here
+            detrended = detrend_with_sinc_filter(
+                signals=self.intensities,
+                cutoff_period=self.sinc_window,
+                sampling_interval=self.frame_interval,
+            )
+            self.finished.emit(detrended)
+        except Exception as e:
+            self.error.emit(e)
+
+
+class PeakDetectionWorker(QObject):
+    """
+    Worker for detecting peaks in detrended traces, wraps the `find_peaks` function.
+    """
+
+    finished = Signal(np.ndarray)
+    error = Signal(Exception)
+
+    def __init__(self, detrended_traces, min_width, max_width, analysis_params, analysis_output):
+        super().__init__()
+        self.traces = detrended_traces
+        self.min_width = min_width
+        self.max_width = max_width
+        self.analysis_params = analysis_params
+        self.analysis_output = analysis_output
+
+    def run(self):
+        try:
+            peak_series, peak_properties_df, peak_frame_nonzero, analysis_output = do_peak_analysis(self.traces, self.min_width, self.max_width, self.analysis_params, self.analysis_output)
+            result = [peak_series, analysis_output]
+            self.finished.emit(result)
+        except Exception as e:
+            self.error.emit(e)
+
+
+class PeriodicCellWorker(QObject):
+    """
+    Worker for finding oscillating ROIs in the peak series, wraps the `find_oscillating_rois` function.
+    """
+
+    finished = Signal(AnalysisOutput, np.ndarray, np.ndarray)
+    error = Signal(Exception)
+
+    def __init__(self, peaks: np.ndarray, analysis_params, analysis_output):
+        super().__init__()
+        self.peaks = peaks
+        self.analysis_output = analysis_output
+        self.analysis_params = analysis_params
+
+    def run(self):
+        try:
+            analysis_output, stds, covs = calculate_periodic_cells(
+                self.peaks, self.analysis_params, self.analysis_output
+            )
+            self.finished.emit(analysis_output, stds, covs)
+        except Exception as e:
+            self.error.emit(e)
+
+
+class AdjacencyMatrixWorker(QObject):
+    """
+    Worker for calculating the adjacency matrix from the masks, wraps the `get_adjacency_matrix` function.
+    """
+
+    finished = Signal(np.ndarray, np.ndarray)
+    error = Signal(Exception)
+
+    def __init__(self, masks: np.ndarray, neighbour_tolerance_pixels: int = 1):
+        super().__init__()
+        self.masks = masks
+        self.neighbour_tolerance_pixels = neighbour_tolerance_pixels
+
+    def run(self):
+        try:
+            adjacency_matrix, shortest_path_matrix = get_adjacency_matrix(
+                self.masks, neighbour_tolerance=self.neighbour_tolerance_pixels
+            )
+            self.finished.emit(adjacency_matrix, shortest_path_matrix)
+        except Exception as e:
+            self.error.emit(e)
+
+
+class SynchronicityWorker(QObject):
+    """
+    Worker for calculating the synchronicity matrix from the detrended intensities, wraps the `calculate_synchronicity_matrix` function.
+    """
+
+    finished = Signal(np.ndarray)
+    error = Signal(Exception)
+
+    def __init__(self, analysis_output:AnalysisOutput, analysis_parameters:AnalysisParameters, peak_series: np.ndarray, shortest_path_matrix: np.ndarray):
+        super().__init__()
+        self.peak_series = peak_series
+        self.shortest_path_matrix = shortest_path_matrix
+        self.analysis_output = analysis_output
+        self.analysis_parameters = analysis_parameters
+
+    def run(self):
+        try:
+            results = calculate_synchronicity(
+                self.shortest_path_matrix,
+                self.peak_series,
+                self.analysis_parameters,
+                self.analysis_output
+            )
+            self.finished.emit(results)
+        except Exception as e:
+            self.error.emit(e)
+
+
+class AnalysisSaveWorker(QObject):
+    """
+    Worker for saving the analysis results, wraps the `save_analysis_results` function.
+    """
+
+    finished = Signal(str)  # emit output file path or summary message
+    error = Signal(Exception)
+
+    def __init__(
+        self,
+        tproj:np.ndarray,
+        masks:np.ndarray,
+        synchronous_peaks_matrix:np.ndarray,
+        analysis_output,
+        analysis_params,
+        peaks: np.ndarray,
+        detrended_intensities: np.ndarray,
+        intensities: np.ndarray,
+        stds: np.ndarray = None,
+        covs: np.ndarray = None,
+        overwrite: bool = False,
+    ):
+        super().__init__()
+        self.tproj = tproj
+        self.masks = masks
+        self.synchronous_peaks_matrix = synchronous_peaks_matrix
+        self.analysis_output = analysis_output
+        self.analysis_params = analysis_params
+        self.peaks = peaks
+        self.detrended_intensities = detrended_intensities
+        self.intensities = intensities
+        self.overwrite = overwrite
+        self.stds = stds
+        self.covs = covs
+
+    def run(self):
+        try:
+            save_analysis_results(
+                tproj=self.tproj,
+                masks=self.masks,
+                synchronous_peaks_matrix=self.synchronous_peaks_matrix,
+                analysis_output=self.analysis_output,
+                analysis_params=self.analysis_params,
+                detrended_intensities=self.detrended_intensities,
+                peaks=self.peaks,
+                intensities=self.intensities,
+                stds=self.stds,
+                covs=self.covs,
+                overwrite=self.overwrite,
+            )
+            self.finished.emit(f"Saved to {self.analysis_output.analysis_folder}")
+
+        except Exception as e:
+            self.error.emit(e)

pykrait-0.3.1/src/pykrait/gui/custom_widgets.py

@@ -0,0 +1,159 @@
+from PySide6.QtWidgets import (
+    QWidget, QLabel, QHBoxLayout, QVBoxLayout, QToolButton, QFrame
+)
+from PySide6.QtCore import Qt, Signal, QRectF, QSize
+from PySide6.QtGui import QPainter, QColor
+
+
+class Slider(QWidget):
+    """Inner slider that paints the track and knob."""
+    toggled = Signal(bool)
+
+    def __init__(self, width=50, height=20, parent=None):
+        super().__init__(parent)
+        self._checked = False
+        self.setFixedSize(width, height)
+        self.setCursor(Qt.PointingHandCursor)
+
+    def paintEvent(self, event):
+        palette = self.palette()
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+
+        # Theme colors
+        color_on = QColor("#DC5801")   # ON highlight
+        color_off = QColor("#8D0F70")  # OFF highlight
+
+        base = palette.base().color()
+        knob_color = palette.window().color() if base.lightness() < 128 else QColor("white")
+
+        # Track
+        track_rect = QRectF(0, 0, self.width(), self.height())
+        track_color = color_on if self._checked else color_off
+        painter.setBrush(track_color)
+        painter.setPen(Qt.NoPen)
+        painter.drawRoundedRect(track_rect, self.height() / 2, self.height() / 2)
+
+        # Knob
+        knob_size = self.height() - 4
+        knob_x = self.width() - knob_size - 2 if self._checked else 2
+        knob_rect = QRectF(knob_x, 2, knob_size, knob_size)
+        painter.setBrush(knob_color)
+        painter.drawEllipse(knob_rect)
+
+    def mousePressEvent(self, event):
+        self._checked = not self._checked
+        self.toggled.emit(self._checked)
+        self.update()
+
+    def is_checked(self):
+        return self._checked
+
+    def set_checked(self, value: bool):
+        self._checked = value
+        self.update()
+
+
+class ToggleSwitch(QWidget):
+    """Boolean toggle with labels outside the slider."""
+    toggled = Signal(bool)
+
+    def __init__(self, label_off="STD", label_on="CoV", parent=None):
+        super().__init__(parent)
+        self.label_off = label_off
+        self.label_on = label_on
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(5, 0, 5, 0)
+        layout.setSpacing(5)
+
+        self.left_label = QLabel(self.label_off)
+        self.left_label.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
+        layout.addWidget(self.left_label)
+
+        self.slider = Slider()
+        self.slider.toggled.connect(self._emit_signal)
+        layout.addWidget(self.slider)
+
+        self.right_label = QLabel(self.label_on)
+        self.right_label.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)
+        layout.addWidget(self.right_label)
+
+    def _emit_signal(self, state):
+        self.toggled.emit(state)
+
+    def is_checked(self):
+        return self.slider.is_checked()
+
+    def set_checked(self, value: bool):
+        self.slider.set_checked(value)
+
+    def value(self) -> str:
+        return self.label_on if self.slider.is_checked() else self.label_off
+
+    def set_labels(self, label_on: str, label_off: str):
+        self.label_on = label_on
+        self.label_off = label_off
+        self.left_label.setText(label_off)
+        self.right_label.setText(label_on)
+
+
+class CollapsibleBox(QWidget):
+    """Collapsible box that adapts to theme colors."""
+    def __init__(self, title="", parent=None, title_font_size=12, arrow_size=10):
+        super().__init__(parent)
+
+        self.toggle_button = QToolButton(text=title, checkable=True, checked=True)
+        self.toggle_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
+        self.toggle_button.setArrowType(Qt.DownArrow)
+        self.toggle_button.setIconSize(QSize(arrow_size, arrow_size))
+        self.toggle_button.setStyleSheet(f"""
+            QToolButton {{
+                border: none;
+                font-weight: bold;
+                font-size: {title_font_size}pt;
+                padding: 5px;
+            }}
+        """)
+        self.toggle_button.clicked.connect(self.on_toggle)
+
+        # Background frame uses palette colors
+        self.bg_frame = QFrame()
+        self.bg_frame.setAutoFillBackground(True)
+        self.update_bg_color()
+
+        self.content_container = QWidget(self.bg_frame)
+        content_layout = QVBoxLayout(self.content_container)
+        content_layout.setContentsMargins(10, 10, 10, 10)
+        content_layout.setSpacing(5)
+        self.content_layout = content_layout
+
+        frame_layout = QVBoxLayout(self.bg_frame)
+        frame_layout.setContentsMargins(0, 0, 0, 0)
+        frame_layout.addWidget(self.content_container)
+
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(self.toggle_button)
+        main_layout.addWidget(self.bg_frame)
+
+        self._expanded = True
+
+    def update_bg_color(self):
+        """Set background color dynamically based on theme."""
+        palette = self.palette()
+        bg = palette.alternateBase().color()
+        self.bg_frame.setStyleSheet(f"""
+            QFrame {{
+                background-color: {bg.name()};
+                border-radius: 8px;
+            }}
+        """)
+
+    def on_toggle(self):
+        self._expanded = not self._expanded
+        self.bg_frame.setVisible(self._expanded)
+        self.toggle_button.setArrowType(Qt.DownArrow if self._expanded else Qt.RightArrow)
+
+    def add_widget(self, widget):
+        self.content_layout.addWidget(widget)