pykrait 0.1.0__tar.gz → 0.2.0__tar.gz

{pykrait-0.1.0 → pykrait-0.2.0}/PKG-INFO

@@ -1,18 +1,23 @@
 Metadata-Version: 2.4
 Name: pykrait
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python Calcium Recording Analysis and Inference Toolbox
 Author-email: Pentabyteman <22663502+Pentabyteman@users.noreply.github.com>
 License: MIT
 License-File: LICENSE
-Requires-Python: >=3.10
-Requires-Dist: aicspylibczi>=3.1.1
+Requires-Python: >=3.11
+Requires-Dist: aicspylibczi>=3.3.1
+Requires-Dist: bioio-czi>=2.4.0
+Requires-Dist: bioio-ome-tiff>=1.1.0
+Requires-Dist: bioio-tifffile>=1.3.0
+Requires-Dist: bioio>=3.0.0
 Requires-Dist: cellpose>=4.0.5
 Requires-Dist: dask>=2025.5.1
 Requires-Dist: fsspec>=2022.8.0
 Requires-Dist: imagecodecs>=2025.3.30
 Requires-Dist: lxml>=5.4.0
 Requires-Dist: matplotlib>=3.10.3
+Requires-Dist: numcodecs<0.16
 Requires-Dist: numpy<2
 Requires-Dist: ome-types>=0.5.3
 Requires-Dist: ome-zarr>=0.10.2
@@ -22,11 +27,22 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: resource-backed-dask-array>=0.1.0
 Requires-Dist: scikit-image>=0.25.2
 Requires-Dist: scipy>=1.15.3
-Requires-Dist: tifffile<2023.3.15,>=2021.8.30
-Requires-Dist: wrapt>=1.17.2
 Requires-Dist: xarray>2025
-Requires-Dist: xmlschema>=4.0.1
-Requires-Dist: zarr<2.16.0,>=2.6
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2.post1; extra == 'dev'
+Requires-Dist: hatch>=1.14.1; extra == 'dev'
+Requires-Dist: ipywidgets>=8.1.7; extra == 'dev'
+Requires-Dist: pydata-sphinx-theme>=0.16.1; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=8.4.1; extra == 'dev'
+Requires-Dist: ruff>=0.11.13; extra == 'dev'
+Requires-Dist: sphinx-autoapi>=3.6.0; extra == 'dev'
+Requires-Dist: sphinx-favicon>=1.0.1; extra == 'dev'
+Requires-Dist: sphinx>=8.1.3; extra == 'dev'
+Requires-Dist: tomli>=2.2.1; extra == 'dev'
+Requires-Dist: twine>=6.1.0; extra == 'dev'
+Provides-Extra: gui
+Requires-Dist: pyside6>=6.9.1; extra == 'gui'
 Description-Content-Type: text/markdown
 
 # pyKrait - Python Calcium Recording Analysis and Inference Toolbox

{pykrait-0.1.0 → pykrait-0.2.0}/pyproject.toml

@@ -1,21 +1,26 @@
 [project]
 name = "pykrait"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python Calcium Recording Analysis and Inference Toolbox"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }
 authors = [
     { name = "Pentabyteman", email = "22663502+Pentabyteman@users.noreply.github.com" }
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
-    "aicspylibczi>=3.1.1",
+    "aicspylibczi>=3.3.1",
+    "bioio>=3.0.0",
+    "bioio-czi>=2.4.0",
+    "bioio-ome-tiff>=1.1.0",
+    "bioio-tifffile>=1.3.0",
     "cellpose>=4.0.5",
     "dask>=2025.5.1",
     "fsspec>=2022.8.0",
     "imagecodecs>=2025.3.30",
     "lxml>=5.4.0",
     "matplotlib>=3.10.3",
+    "numcodecs<0.16",
     "numpy<2",
     "ome-types>=0.5.3",
     "ome-zarr>=0.10.2",
@@ -25,11 +30,26 @@ dependencies = [
     "resource-backed-dask-array>=0.1.0",
     "scikit-image>=0.25.2",
     "scipy>=1.15.3",
-    "tifffile>=2021.8.30,<2023.3.15",
-    "wrapt>=1.17.2",
     "xarray>2025",
-    "xmlschema>=4.0.1",
-    "zarr>=2.6,<2.16.0",
+]
+
+[project.optional-dependencies]
+gui = [
+    "pyside6>=6.9.1"
+]
+dev = [
+    "build>=1.2.2.post1",
+    "hatch>=1.14.1",
+    "ipywidgets>=8.1.7",
+    "pydata-sphinx-theme>=0.16.1",
+    "ruff>=0.11.13",
+    "sphinx>=8.1.3",
+    "sphinx-autoapi>=3.6.0",
+    "sphinx-favicon>=1.0.1",
+    "tomli>=2.2.1",
+    "twine>=6.1.0",
+    "pytest>=8.4.1",
+    "pytest-cov"
 ]
 
 [build-system]
@@ -55,17 +75,3 @@ source = ["stavromueller_beta"]
 [tool.coverage.report]
 show_missing = true
 skip_covered = true
-
-[dependency-groups]
-dev = [
-    "build>=1.2.2.post1",
-    "hatch>=1.14.1",
-    "ipywidgets>=8.1.7",
-    "pydata-sphinx-theme>=0.16.1",
-    "ruff>=0.11.13",
-    "sphinx>=8.1.3",
-    "sphinx-autoapi>=3.6.0",
-    "sphinx-favicon>=1.0.1",
-    "tomli>=2.2.1",
-    "twine>=6.1.0",
-]

pykrait-0.2.0/src/.python-version

@@ -0,0 +1 @@
+3.11

pykrait-0.2.0/src/pykrait/__main__.py

@@ -0,0 +1,41 @@
+"""
+Copyright © 2025 Pentabyteman
+"""
+# src/pykrait/__main__.py
+
+import sys
+from PySide6.QtWidgets import QApplication
+from pykrait.gui.fileselection import FileSelectionWindow
+from pykrait.gui.mainwindow import MainWindow
+
+class AppController:
+    def __init__(self):
+        self.app = QApplication(sys.argv)
+        self.file_selection = FileSelectionWindow()
+        self.file_selection.analysis_complete.connect(self.on_analysis_complete)
+        self.file_selection.show()
+
+        # Keep references to windows
+        self.main_window = None
+
+    def on_analysis_complete(self, results):
+        # Called when analysis is done in FileSelectionWindow
+        # Hide file selection window
+        self.file_selection.close()
+        # Launch main window, keep reference
+        self.main_window = MainWindow(
+            frames=results["frames"],
+            mask=results["masks"],
+            mean_intensities=results["mean_intensities"],
+            analysis_output=results["analysis_output"],
+            analysis_params=results["analysis_parameters"]
+        )
+        self.main_window.show()
+
+    def run(self):
+        sys.exit(self.app.exec())
+
+# In __main__.py
+if __name__ == "__main__":
+    controller = AppController()
+    controller.run()

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

@@ -0,0 +1,167 @@
+from PySide6.QtCore import QObject, Signal, Slot
+import tifffile
+import warnings
+import os
+import traceback
+import numpy as np
+
+from pykrait.io.io import load_timelapse_lazy
+from pykrait.preprocessing.segmentation import timelapse_projection, create_cellpose_segmentation
+from pykrait.preprocessing.timeseries_extraction import extract_mean_intensities
+from pykrait.trace_analysis.filtering import detrend_with_sinc_filter
+from pykrait.trace_analysis.peak_analysis import find_peaks
+from pykrait.trace_analysis.oscillations import find_oscillating_rois
+from pykrait.pipeline.pipeline import AnalysisParameters, AnalysisOutput
+
+class ExtractIntensitiesWorker(QObject):
+    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):
+        super().__init__()
+        self.analysis_parameters = analysis_params
+        self.analysis_output = output_params
+        self.mode = mode
+
+    @Slot()
+    def run(self):
+        try:
+            
+            self.analysis_output.filename = self.analysis_output.filepath.split("/")[-1]
+            print(f"Running analysis on {self.analysis_output.filename}")
+            # Create analysis folder in the parent directory of the video file
+            parent_dir = os.path.dirname(self.analysis_output.filepath)
+            filename_wo_ext = os.path.splitext(self.analysis_output.filename)[0]
+            analysis_folder = os.path.join(parent_dir, f"Analysis_{filename_wo_ext}")
+            os.makedirs(analysis_folder, exist_ok=True)
+            self.analysis_output.analysis_folder = analysis_folder
+
+            self.progress_changed.emit(5, "Loading timelapse...")
+
+            timelapse_data, frame_interval, self.analysis_output.pixel_interval_y, self.analysis_output.pixel_interval_x = load_timelapse_lazy(file_path = self.analysis_output.filepath)
+
+            if frame_interval is None and self.analysis_parameters.frame_interval is None:
+                warnings.warn("No frame interval provided in the analysis parameters, and no frame interval could be inferred from the metadata. Defaulting to 1 second.")
+                self.analysis_output.frame_interval = 1  # Default to 1 second if not provided
+            elif self.analysis_parameters.frame_interval is None and frame_interval is not None:
+                self.analysis_output.frame_interval = frame_interval
+            elif frame_interval is not None and self.analysis_parameters.frame_interval != frame_interval:
+                warnings.warn(f"Provided frame_interval ({self.analysis_parameters.frame_interval}) does not match inferred frame_interval ({frame_interval}) from metadata. Using provided value.")
+
+            if self.mode == "cellpose":
+                # perform the tproj
+                self.progress_changed.emit(10, "Performing T Projection...")
+                tproj = timelapse_projection(timelapse_data, method=self.analysis_parameters.tproj_type, normalize=self.analysis_parameters.CLAHE_normalize, verbose=True)
+                tproj_path = os.path.join(analysis_folder, f"{filename_wo_ext}_tproj.ome.tif")
+                self.analysis_output.tproj_path = tproj_path
+                tifffile.imwrite(tproj_path, tproj.astype(np.uint16), metadata={'axes': 'CYX'}, compression="zlib")
+                self.analysis_output.zproj_path = os.path.join(analysis_folder, f"{filename_wo_ext}_zproj.ome.tif")
+
+                # create cellpose segmentation
+                self.progress_changed.emit(30, "Performing Cellpose Segmentation...")    
+                masks = create_cellpose_segmentation(tproj, cellpose_model_path=self.analysis_parameters.cellpose_model_path)
+                mask_path = os.path.join(analysis_folder, f"{filename_wo_ext}_cp_masks.ome.tif")
+                self.analysis_output.mask_path = mask_path
+                tifffile.imwrite(mask_path, masks.astype(np.uint16), metadata={'axes': 'YX'}, compression="zlib")
+                
+            elif self.mode == "label_image":
+                self.progress_changed.emit(20, "Loading label image...")
+                masks = tifffile.imread(self.analysis_output.masks_path)
+                tproj = None  # Not needed in this mode
+
+            else:
+                raise ValueError("Unknown mode.")
+
+            # extracts the mean intensities of the masks
+            self.progress_changed.emit(60, "Extracting intensities...") 
+            mean_intensities = extract_mean_intensities(timelapse_data, masks)
+            self.analysis_output.number_of_frames, self.analysis_output.number_of_cells = mean_intensities.shape
+
+            # All done
+            self.progress_changed.emit(100, "Done.")
+            
+            results = {
+                'frames': timelapse_data,
+                'analysis_output': self.analysis_output,
+                'analysis_parameters': self.analysis_parameters,
+                'masks': masks,
+                'mean_intensities': mean_intensities
+            }
+            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):
+    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):
+    finished = Signal(np.ndarray)
+    error = Signal(Exception)
+
+    def __init__(self, detrended_traces, min_width, max_width, prominence, min_height):
+        super().__init__()
+        self.traces = detrended_traces
+        self.min_width = min_width
+        self.max_width = max_width
+        self.prominence = prominence
+        self.min_height = min_height
+
+    def run(self):
+        try:
+            peaks = find_peaks(
+                peak_min_width=self.min_width,
+                peak_max_width=self.max_width,
+                peak_prominence=self.prominence,
+                peak_min_height=self.min_height,
+                detrended_timeseries=self.traces
+            )
+            self.finished.emit(peaks)
+        except Exception as e:
+            self.error.emit(e)
+
+class PeriodicCellWorker(QObject):
+    finished = Signal(float, int, int, float, int, int)
+    error = Signal(Exception)
+
+    def __init__(self, peaks: np.ndarray, frame_interval: float, std_t: float = 0.01, cov_t: float = 0.01):
+        super().__init__()
+        self.peaks = peaks
+        self.frame_interval = frame_interval
+        self.std_t = std_t
+        self.cov_t = cov_t
+
+    def run(self):
+        try:
+            filtered_peak_series = self.peaks[:, np.sum(self.peaks, axis=0) >= 4]
+            result = find_oscillating_rois(
+                filtered_peak_series,
+                std_threshold=self.std_t,
+                cov_threshold=self.cov_t,
+                frame_interval=self.frame_interval,
+            )
+            self.finished.emit(*result)
+        except Exception as e:
+            self.error.emit(e)
+