spacr 0.2.46__py3-none-any.whl → 0.2.56__py3-none-any.whl

spacr/gui_utils.py

@@ -1,5 +1,4 @@
 import os, io, sys, ast, ctypes, ast, sqlite3, requests, time, traceback
-import traceback
 import tkinter as tk
 from tkinter import ttk
 import matplotlib
@@ -7,8 +6,7 @@ import matplotlib.pyplot as plt
 matplotlib.use('Agg')
 from huggingface_hub import list_repo_files
 
-from . gui_core import initiate_root
-from .gui_elements import AnnotateApp, spacrEntry, spacrCheck, spacrCombo, set_default_font
+from .gui_elements import AnnotateApp, spacrEntry, spacrCheck, spacrCombo
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
@@ -28,6 +26,10 @@ def proceed_with_app(root, app_name, app_func):
     app_func(root.content_frame)
 
 def load_app(root, app_name, app_func):
+    # Clear the canvas if it exists
+    if root.canvas is not None:
+        root.clear_frame(root.canvas)
+
     # Cancel all scheduled after tasks
     if hasattr(root, 'after_tasks'):
         for task in root.after_tasks:
@@ -37,70 +39,90 @@ def load_app(root, app_name, app_func):
     # Exit functionality only for the annotation and make_masks apps
     if app_name not in ["Annotate", "make_masks"] and hasattr(root, 'current_app_exit_func'):
         root.next_app_func = proceed_with_app
-        root.next_app_args = (app_name, app_func)  # Ensure correct arguments
+        root.next_app_args = (app_name, app_func)
         root.current_app_exit_func()
     else:
         proceed_with_app(root, app_name, app_func)
-
+    
 def parse_list_v1(value):
     try:
         parsed_value = ast.literal_eval(value)
         if isinstance(parsed_value, list):
             return parsed_value
         else:
-            raise ValueError
-    except (ValueError, SyntaxError):
-        raise ValueError("Invalid format for list")
+            raise ValueError(f"Expected a list but got {type(parsed_value).__name__}")
+    except (ValueError, SyntaxError) as e:
+        raise ValueError(f"Invalid format for list: {value}. Error: {e}")
     
 def parse_list(value):
     try:
         parsed_value = ast.literal_eval(value)
         if isinstance(parsed_value, list):
-            return parsed_value
+            # Check if the list elements are homogeneous (all int or all str)
+            if all(isinstance(item, int) for item in parsed_value):
+                return parsed_value
+            elif all(isinstance(item, str) for item in parsed_value):
+                return parsed_value
+            else:
+                raise ValueError("List contains mixed types or unsupported types")
         else:
             raise ValueError(f"Expected a list but got {type(parsed_value).__name__}")
     except (ValueError, SyntaxError) as e:
         raise ValueError(f"Invalid format for list: {value}. Error: {e}")
-    
+
 # Usage example in your create_input_field function
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
-    from .gui_elements import set_dark_style
+    from .gui_elements import set_dark_style, set_element_size
     label_column = 0
-    widget_column = 1
+    widget_column = 0  # Both label and widget will be in the same column
 
     style_out = set_dark_style(ttk.Style())
+    font_loader = style_out['font_loader']
+    font_size = style_out['font_size']
+    size_dict = set_element_size()
+    size_dict['settings_width'] = size_dict['settings_width'] - int(size_dict['settings_width']*0.1)
 
     # Replace underscores with spaces and capitalize the first letter
     label_text = label_text.replace('_', ' ').capitalize()
 
     # Configure the column widths
-    frame.grid_columnconfigure(label_column, weight=0)  # Allow the label column to expand
-    frame.grid_columnconfigure(widget_column, weight=1)  # Allow the widget column to expand
+    frame.grid_columnconfigure(label_column, weight=1)  # Allow the column to expand
+
+    # Create a custom frame with a translucent background and rounded edges
+    custom_frame = tk.Frame(frame, bg=style_out['bg_color'], bd=2, relief='solid', width=size_dict['settings_width'])
+    custom_frame.grid(column=label_column, row=row, sticky=tk.EW, padx=(5, 5), pady=5)
+
+    # Apply styles to custom frame
+    custom_frame.update_idletasks()
+    custom_frame.config(highlightbackground=style_out['bg_color'], highlightthickness=1, bd=2)
 
     # Create and configure the label
-    label = ttk.Label(frame, text=label_text, background=style_out['bg_color'], foreground=style_out['fg_color'], font=(style_out['font_family'], style_out['font_size']), anchor='e', justify='right')
-    label.grid(column=label_column, row=row, sticky=tk.E, padx=(5, 2), pady=5)
+    if font_loader:
+        label = ttk.Label(custom_frame, text=label_text, background=style_out['bg_color'], foreground=style_out['fg_color'], font=font_loader.get_font(size=font_size), anchor='e', justify='right')
+    label = ttk.Label(custom_frame, text=label_text, background=style_out['bg_color'], foreground=style_out['fg_color'], font=(style_out['font_family'], style_out['font_size']), anchor='e', justify='right')
+    label.grid(column=label_column, row=0, sticky=tk.W, padx=(5, 2), pady=5)  # Place the label in the first row
 
+    # Create and configure the input widget based on var_type
     if var_type == 'entry':
         var = tk.StringVar(value=default_value)
-        entry = spacrEntry(frame, textvariable=var, outline=False)
-        entry.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
-        return (label, entry, var)  # Return both the label and the entry, and the variable
+        entry = spacrEntry(custom_frame, textvariable=var, outline=False, width=size_dict['settings_width'])
+        entry.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the entry in the second row
+        return (label, entry, var, custom_frame)  # Return both the label and the entry, and the variable
     elif var_type == 'check':
         var = tk.BooleanVar(value=default_value)  # Set default value (True/False)
-        check = spacrCheck(frame, text="", variable=var)
-        check.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
-        return (label, check, var)  # Return both the label and the checkbutton, and the variable
+        check = spacrCheck(custom_frame, text="", variable=var)
+        check.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the checkbutton in the second row
+        return (label, check, var, custom_frame)  # Return both the label and the checkbutton, and the variable
     elif var_type == 'combo':
         var = tk.StringVar(value=default_value)  # Set default value
-        combo = spacrCombo(frame, textvariable=var, values=options)  # Apply TCombobox style
-        combo.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
+        combo = spacrCombo(custom_frame, textvariable=var, values=options, width=size_dict['settings_width'])  # Apply TCombobox style
+        combo.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the combobox in the second row
         if default_value:
             combo.set(default_value)
-        return (label, combo, var)  # Return both the label and the combobox, and the variable
+        return (label, combo, var, custom_frame)  # Return both the label and the combobox, and the variable
     else:
         var = None  # Placeholder in case of an undefined var_type
-        return (label, None, var)
+        return (label, None, var, custom_frame)
 
 def process_stdout_stderr(q):
     """
@@ -116,10 +138,9 @@ class WriteToQueue(io.TextIOBase):
     """
     def __init__(self, q):
         self.q = q
-
     def write(self, msg):
-        self.q.put(msg)
-
+        if msg.strip():  # Avoid empty messages
+            self.q.put(msg)
     def flush(self):
         pass
 
@@ -309,23 +330,6 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     # Call load_images after setting up the root window
     app.load_images()
 
-def set_element_size(widget):
-    screen_width = widget.winfo_screenwidth()
-    screen_height = widget.winfo_screenheight()
-    btn_size = screen_width // 40
-    bar_size = screen_width // 50
-    settings_width = screen_width // 5
-    panel_height = screen_height // 12
-    panel_width = settings_width
-    size_dict = {
-        'btn_size': btn_size,
-        'bar_size': bar_size,
-        'settings_width': settings_width,
-        'panel_width': panel_width,
-        'panel_height': panel_height
-    }
-    return size_dict
-
 def convert_settings_dict_for_gui(settings):
     from torchvision import models as torch_models
     torchvision_models = [name for name, obj in torch_models.__dict__.items() if callable(obj)]
@@ -335,7 +339,9 @@ def convert_settings_dict_for_gui(settings):
     special_cases = {
         'metadata_type': ('combo', ['cellvoyager', 'cq1', 'nikon', 'zeis', 'custom'], 'cellvoyager'),
         'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'train_channels': ('combo', ["['r','g','b']", "['r','g']", "['r','b']", "['g','b']", "['r']", "['g']", "['b']"], "['r','g','b']"),
         'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'annotate'),
         'cell_mask_dim': ('combo', chans, None),
         'cell_chann_dim': ('combo', chans, None),
         'nucleus_mask_dim': ('combo', chans, None),
@@ -381,8 +387,10 @@ def convert_settings_dict_for_gui(settings):
             variables[key] = ('entry', None, str(value))
         else:
             variables[key] = ('entry', None, str(value))
+    
     return variables
 
+
 def spacrFigShow(fig_queue=None):
     """
     Replacement for plt.show() that queues figures instead of displaying them.
@@ -424,13 +432,14 @@ def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imp
         plt.show = original_show
 
 def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
+    
     from .gui_utils import process_stdout_stderr
-    from .core import preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
+    from .core import generate_image_umap, preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
     from .io import generate_cellpose_train_test
     from .measure import measure_crop
     from .sim import run_multiple_simulations
-    from .deep_spacr import train_test_model
-    from .sequencing import analyze_reads, map_barcodes_folder, perform_regression
+    from .deep_spacr import deep_spacr
+    from .sequencing import generate_barecode_mapping, perform_regression
     process_stdout_stderr(q)
 
     print(f'run_function_gui settings_type: {settings_type}') 
@@ -444,12 +453,9 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     elif settings_type == 'simulation':
         function = run_multiple_simulations
         imports = 1
-    elif settings_type == 'sequencing':
-        function = analyze_reads
-        imports = 1
     elif settings_type == 'classify':
-        function = train_test_model
-        imports = 2
+        function = deep_spacr
+        imports = 1
     elif settings_type == 'train_cellpose':
         function = train_cellpose
         imports = 1
@@ -463,14 +469,17 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
         function = check_cellpose_models
         imports = 1
     elif settings_type == 'map_barcodes':
-        function = map_barcodes_folder
-        imports = 2
+        function = generate_barecode_mapping
+        imports = 1
     elif settings_type == 'regression':
         function = perform_regression
         imports = 2
     elif settings_type == 'recruitment':
         function = analyze_recruitment
         imports = 2
+    elif settings_type == 'umap':
+        function = generate_image_umap
+        imports = 1
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     try:
@@ -481,6 +490,7 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     finally:
         stop_requested.value = 1
 
+
 def hide_all_settings(vars_dict, categories):
     """
     Function to initially hide all settings in the GUI.
@@ -495,26 +505,27 @@ def hide_all_settings(vars_dict, categories):
 
     for category, settings in categories.items():
         if any(setting in vars_dict for setting in settings):
-            vars_dict[category] = (None, None, tk.IntVar(value=0))
+            vars_dict[category] = (None, None, tk.IntVar(value=0), None)
             
             # Initially hide all settings
             for setting in settings:
                 if setting in vars_dict:
-                    label, widget, _ = vars_dict[setting]
+                    label, widget, _, frame = vars_dict[setting]
                     label.grid_remove()
                     widget.grid_remove()
+                    frame.grid_remove()
     return vars_dict
 
 def setup_frame(parent_frame):
-    from .gui_elements import set_dark_style, set_default_font
+    from .gui_elements import set_dark_style, set_element_size
 
     style = ttk.Style(parent_frame)
-    size_dict = set_element_size(parent_frame)
+    size_dict = set_element_size()
     style_out = set_dark_style(style)
 
     settings_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, width=size_dict['settings_width'], bg=style_out['bg_color'])
-    vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, bg=style_out['bg_color'])
-    horizontal_container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL, height=size_dict['panel_height'], bg=style_out['bg_color'])
+    vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, width=size_dict['panel_width'], bg=style_out['bg_color'])
+    horizontal_container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL, height=size_dict['panel_height'], width=size_dict['panel_width'], bg=style_out['bg_color'])
 
     parent_frame.grid_rowconfigure(0, weight=1)
     parent_frame.grid_rowconfigure(1, weight=0)
@@ -523,22 +534,18 @@ def setup_frame(parent_frame):
 
     settings_container.grid(row=0, column=0, rowspan=2, sticky="nsew")
     vertical_container.grid(row=0, column=1, sticky="nsew")
-    horizontal_container.grid(row=1, column=1, sticky="nsew")
+    horizontal_container.grid(row=1, column=1, sticky="ew")
 
-    # Lock the width of the horizontal_container
-    horizontal_container.update_idletasks()  # Ensure geometry manager calculates size
-    fixed_width = horizontal_container.winfo_width()
-    parent_frame.grid_columnconfigure(1, weight=0)
-    horizontal_container.config(width=fixed_width)
+    # Ensure settings_container maintains its width
+    settings_container.grid_propagate(False)
+    settings_container.update_idletasks()
 
-    tk.Label(settings_container, text="Settings Container", bg=style_out['bg_color']).pack(fill=tk.BOTH, expand=True)
-    tk.Label(vertical_container, text="Vertical Container", bg=style_out['bg_color']).pack(fill=tk.BOTH, expand=True)
+    tk.Label(settings_container, text="Settings Container", bg=style_out['bg_color']).grid(row=0, column=0, sticky="ew")
 
     set_dark_style(style, parent_frame, [settings_container, vertical_container, horizontal_container])
     
-    size = style_out['font_size'] - 2
-    
-    set_default_font(parent_frame, font_name=style_out['font_family'], size=size)
+    #size = style_out['font_size'] - 2
+    #set_default_font(parent_frame, font_name=style_out['font_family'], size=size)
 
     return parent_frame, vertical_container, horizontal_container, settings_container
 
@@ -622,3 +629,7 @@ def download_dataset(q, repo_id, subfolder, local_dir=None, retries=5, delay=5):
             time.sleep(delay)
 
     raise Exception("Failed to download files after multiple attempts.")
+
+def ensure_after_tasks(frame):
+    if not hasattr(frame, 'after_tasks'):
+        frame.after_tasks = []

spacr/io.py

@@ -597,7 +597,6 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
         for idx in range(0, len(all_filenames), batch_size):
             start = time.time()
             batch_filenames = all_filenames[idx:idx+batch_size]
-            files_processed = 0
             for filename in batch_filenames:
                 images_by_key = _extract_filename_metadata(batch_filenames, src, images_by_key, regular_expression, metadata_type, pick_slice, skip_mode)
             
@@ -974,7 +973,7 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
                 time_ls.append(duration)
                 files_processed = i+1
                 files_to_process = time_stack_path_lists
-                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Concatinating")
+                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type="Concatinating")
                 stack = np.stack(stack_region)
                 save_loc = os.path.join(channel_stack_loc, f'{name}.npz')
                 np.savez(save_loc, data=stack, filenames=filenames_region)
@@ -1005,7 +1004,7 @@ def _concatenate_channel(src, channels, randomize=True, timelapse=False, batch_s
             time_ls.append(duration)
             files_processed = i+1
             files_to_process = nr_files
-            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Concatinating")
+            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type="Concatinating")
             if (i+1) % batch_size == 0 or i+1 == nr_files:
                 unique_shapes = {arr.shape[:-1] for arr in stack_ls}
                 if len(unique_shapes) > 1:
@@ -2294,15 +2293,23 @@ def _save_model(model, model_type, results_df, dst, epoch, epochs, intermedeate_
     def save_model_at_threshold(threshold, epoch, suffix=""):
         percentile = str(threshold * 100)
         print(f'\rfound: {percentile}% accurate model')#, end='\r', flush=True)
-        torch.save(model, f'{dst}/{model_type}_epoch_{str(epoch)}{suffix}_acc_{percentile}_channels_{channels_str}.pth')
+        model_path = f'{dst}/{model_type}_epoch_{str(epoch)}{suffix}_acc_{percentile}_channels_{channels_str}.pth'
+        torch.save(model, model_path)
+        return model_path
 
     if epoch % 100 == 0 or epoch == epochs:
-        torch.save(model, f'{dst}/{model_type}_epoch_{str(epoch)}_channels_{channels_str}.pth')
+        model_path = f'{dst}/{model_type}_epoch_{str(epoch)}_channels_{channels_str}.pth'
+        torch.save(model, model_path)
+        return model_path
 
     for threshold in intermedeate_save:
         if results_df['neg_accuracy'].dropna().mean() >= threshold and results_df['pos_accuracy'].dropna().mean() >= threshold:
-            save_model_at_threshold(threshold, epoch)
-            break  # Ensure we only save for the highest matching threshold
+            model_path = save_model_at_threshold(threshold, epoch)
+            break
+        else:
+            model_path = None
+    
+    return model_path
 
 def _save_progress(dst, results_df, train_metrics_df, epoch, epochs):
     """