spacr 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

spacr/__init__.py

@@ -41,7 +41,6 @@ __all__ = [
     "app_annotate",
     "gui_utils",
     "app_make_masks",
-    "app_make_masks_v2",
     "app_mask",
     "app_measure",
     "app_classify",

spacr/app_annotate.py

@@ -485,12 +485,15 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     exit_button = tk.Button(root, text="Exit", command=lambda: [app.shutdown(), shutdown_callback()], background='black', foreground='white')
     exit_button.grid(row=app.grid_rows, column=app.grid_cols - 3)
 
-    app.load_images()
+    #app.load_images()
 
     # Store the shutdown function and next app details in the root
     root.current_app_exit_func = lambda: [app.shutdown(), shutdown_callback()]
     root.next_app_func = proceed_with_app
-    root.next_app_args = ("Main App", gui_app)  # Specify the main app function
+    root.next_app_args = ("Main App", gui_app)
+
+    # Call load_images after setting up the root window
+    app.load_images()
 
 def load_next_app(root):
     # Get the next app function and arguments

spacr/core.py

@@ -971,7 +971,7 @@ def generate_dataset(src, file_metadata=None, experiment='TSG101_screen', sample
     shutil.rmtree(temp_dir)
     print(f"\nSaved {total_images} images to {tar_name}")
 
-def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=224, batch_size=64, normalize=True, preload='images', num_workers=10, threshold=0.5, verbose=False):
+def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=224, batch_size=64, normalize=True, preload='images', n_job=10, threshold=0.5, verbose=False):
     
     from .io import TarImageDataset
     from .utils import process_vision_results
@@ -994,7 +994,7 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
     model = torch.load(model_path)
     
     dataset = TarImageDataset(tar_path, transform=transform)
-    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=True)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_job=n_job, pin_memory=True)
     
     model_name = os.path.splitext(os.path.basename(model_path))[0] 
     dataset_name = os.path.splitext(os.path.basename(tar_path))[0]  
@@ -1034,7 +1034,7 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
     torch.cuda.memory.empty_cache()
     return df
 
-def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True, num_workers=10):
+def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True, n_job=10):
     
     from .io import NoClassDataset
     
@@ -1055,7 +1055,7 @@ def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True,
     
     print(f'Loading dataset in {src} with {len(src)} images')
     dataset = NoClassDataset(data_dir=src, transform=transform, shuffle=True, load_to_memory=False)
-    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_job=n_job)
     print(f'Loaded {len(src)} images')
     
     result_loc = os.path.splitext(model_path)[0]+datetime.date.today().strftime('%y%m%d')+'_'+os.path.splitext(model_path)[1]+'_test_result.csv'
@@ -1302,7 +1302,7 @@ def generate_training_dataset(src, mode='annotation', annotation_column='test',
     
     return
 
-def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_size=32, classes=['nc','pc'], num_workers=None, validation_split=0.0, max_show=2, pin_memory=False, normalize=False, channels=[1, 2, 3], augment=False, verbose=False):
+def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_size=32, classes=['nc','pc'], n_job=None, validation_split=0.0, max_show=2, pin_memory=False, normalize=False, channels=[1, 2, 3], augment=False, verbose=False):
     
     """
     Generate data loaders for training and validation/test datasets.
@@ -1314,7 +1314,7 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
     - image_size (int): The size of the input images.
     - batch_size (int): The batch size for the data loaders.
     - classes (list): The list of classes to consider.
-    - num_workers (int): The number of worker threads for data loading.
+    - n_job (int): The number of worker threads for data loading.
     - validation_split (float): The fraction of data to use for validation when train_mode is 'erm'.
     - max_show (int): The maximum number of images to show when verbose is True.
     - pin_memory (bool): Whether to pin memory for faster data transfer.
@@ -1404,10 +1404,10 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
                 #val_dataset = augment_dataset(val_dataset, is_grayscale=(len(channels) == 1))
                 print(f'Data after augmentation: Train: {len(train_dataset)}')#, Validataion:{len(val_dataset)}')
 
-            train_loaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
-            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
+            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
         else:
-            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
         
     elif train_mode == 'irm':
         data = MyDataset(data_dir, classes, transform=transform, shuffle=shuffle, pin_memory=pin_memory)
@@ -1436,13 +1436,13 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
                     #val_dataset = augment_dataset(val_dataset, is_grayscale=(len(channels) == 1))
                     print(f'Data after augmentation: Train: {len(train_dataset)}')#, Validataion:{len(val_dataset)}')
 
-                train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
-                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
+                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
 
                 train_loaders.append(train_loader)
                 val_loaders.append(val_loader)
             else:
-                train_loader = DataLoader(plate_data, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(plate_data, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
                 train_loaders.append(train_loader)
                 val_loaders.append(None)
     
@@ -1668,7 +1668,7 @@ def preprocess_generate_masks(src, settings={}):
 
     from .io import preprocess_img_data, _load_and_concatenate_arrays
     from .plot import plot_merged, plot_arrays
-    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks, _merge_cells_based_on_parasite_overlap, process_masks
+    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks
     from .settings import set_default_settings_preprocess_generate_masks, set_default_plot_merge_settings
     
     settings = set_default_settings_preprocess_generate_masks(src, settings)
@@ -2078,11 +2078,11 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
                             else:
                                 radius = 100
 
-                            workers = os.cpu_count()-2
-                            if workers < 1:
-                                workers = 1
+                            n_job = os.cpu_count()-2
+                            if n_job < 1:
+                                n_job = 1
 
-                            mask_stack = _btrack_track_cells(src, name, batch_filenames, object_type, plot, save, masks_3D=masks, mode=timelapse_mode, timelapse_remove_transient=timelapse_remove_transient, radius=radius, workers=workers)
+                            mask_stack = _btrack_track_cells(src, name, batch_filenames, object_type, plot, save, masks_3D=masks, mode=timelapse_mode, timelapse_remove_transient=timelapse_remove_transient, radius=radius, n_job=n_job)
                         if timelapse_mode == 'trackpy':
                             mask_stack = _trackpy_track_cells(src, name, batch_filenames, object_type, masks, timelapse_displacement, timelapse_memory, timelapse_remove_transient, plot, save, timelapse_mode)
                             
@@ -2303,9 +2303,9 @@ def generate_cellpose_masks(src, settings, object_type):
                         else:
                             radius = 100
 
-                        workers = os.cpu_count()-2
-                        if workers < 1:
-                            workers = 1
+                        n_job = os.cpu_count()-2
+                        if n_job < 1:
+                            n_job = 1
 
                         mask_stack = _btrack_track_cells(src=src,
                                                          name=name,
@@ -2317,7 +2317,7 @@ def generate_cellpose_masks(src, settings, object_type):
                                                          mode=timelapse_mode,
                                                          timelapse_remove_transient=timelapse_remove_transient,
                                                          radius=radius,
-                                                         workers=workers)
+                                                         n_job=n_job)
                     if timelapse_mode == 'trackpy':
                         mask_stack = _trackpy_track_cells(src=src,
                                                           name=name,
@@ -2551,7 +2551,7 @@ def compare_cellpose_masks(src, verbose=False, processes=None, save=True):
         common_files.intersection_update(os.listdir(d))
     common_files = list(common_files)
 
-    # Create a pool of workers
+    # Create a pool of n_job
     with Pool(processes=processes) as pool:
         args = [(src, filename, dirs, conditions) for filename in common_files]
         results = pool.map(compare_mask, args)

spacr/deep_spacr.py

@@ -230,7 +230,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                     image_size=settings['image_size'],
                                                     batch_size=settings['batch_size'], 
                                                     classes=settings['classes'], 
-                                                    num_workers=settings['num_workers'],
+                                                    n_job=settings['n_job'],
                                                     validation_split=settings['val_split'],
                                                     pin_memory=settings['pin_memory'],
                                                     normalize=settings['normalize'],
@@ -255,7 +255,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                             optimizer_type = settings['optimizer_type'], 
                             use_checkpoint = settings['use_checkpoint'], 
                             dropout_rate = settings['dropout_rate'], 
-                            num_workers = settings['num_workers'], 
+                            n_job = settings['n_job'], 
                             val_loaders = val, 
                             test_loaders = None, 
                             intermedeate_save = settings['intermedeate_save'],
@@ -276,7 +276,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                      image_size=settings['image_size'],
                                                      batch_size=settings['batch_size'], 
                                                      classes=settings['classes'], 
-                                                     num_workers=settings['num_workers'],
+                                                     n_job=settings['n_job'],
                                                      validation_split=0.0,
                                                      pin_memory=settings['pin_memory'],
                                                      normalize=settings['normalize'],
@@ -315,7 +315,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
     torch.cuda.memory.empty_cache()
     gc.collect()
     
-def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='erm', epochs=100, learning_rate=0.0001, weight_decay=0.05, amsgrad=False, optimizer_type='adamw', use_checkpoint=False, dropout_rate=0, num_workers=20, val_loaders=None, test_loaders=None, init_weights='imagenet', intermedeate_save=None, chan_dict=None, schedule = None, loss_type='binary_cross_entropy_with_logits', gradient_accumulation=False, gradient_accumulation_steps=4, channels=['r','g','b']):
+def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='erm', epochs=100, learning_rate=0.0001, weight_decay=0.05, amsgrad=False, optimizer_type='adamw', use_checkpoint=False, dropout_rate=0, n_job=20, val_loaders=None, test_loaders=None, init_weights='imagenet', intermedeate_save=None, chan_dict=None, schedule = None, loss_type='binary_cross_entropy_with_logits', gradient_accumulation=False, gradient_accumulation_steps=4, channels=['r','g','b']):
     """
     Trains a model using the specified parameters.
 
@@ -332,7 +332,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
         optimizer_type (str, optional): The type of optimizer to use. Defaults to 'adamw'.
         use_checkpoint (bool, optional): Whether to use checkpointing during training. Defaults to False.
         dropout_rate (float, optional): The dropout rate for the model. Defaults to 0.
-        num_workers (int, optional): The number of workers for data loading. Defaults to 20.
+        n_job (int, optional): The number of n_job for data loading. Defaults to 20.
         val_loaders (list, optional): A list of validation data loaders. Defaults to None.
         test_loaders (list, optional): A list of test data loaders. Defaults to None.
         init_weights (str, optional): The initialization weights for the model. Defaults to 'imagenet'.
@@ -357,7 +357,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
         
     use_cuda = torch.cuda.is_available()
     device = torch.device("cuda" if use_cuda else "cpu")
-    kwargs = {'num_workers': num_workers, 'pin_memory': True} if use_cuda else {}
+    kwargs = {'n_job': n_job, 'pin_memory': True} if use_cuda else {}
     
     for idx, (images, labels, filenames) in enumerate(train_loaders):
         batch, chans, height, width = images.shape

spacr/gui_core.py

@@ -5,7 +5,9 @@ from tkinter import ttk
 import tkinter.font as tkFont
 from tkinter import filedialog
 from tkinter import font as tkFont
-from multiprocessing import Process, Value, Queue, Manager, set_start_method
+from multiprocessing import Process, Value, Queue
+from multiprocessing.sharedctypes import Synchronized
+from multiprocessing import set_start_method
 from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
@@ -37,21 +39,18 @@ thread_control = {"run_thread": None, "stop_requested": False}
 
 def initiate_abort():
     global thread_control
-    if thread_control.get("stop_requested") is not None:
-        if isinstance(thread_control["stop_requested"], Value):
-            thread_control["stop_requested"].value = 1
-
+    if isinstance(thread_control.get("stop_requested"), Synchronized):
+        thread_control["stop_requested"].value = 1
     if thread_control.get("run_thread") is not None:
-        thread_control["run_thread"].join(timeout=5)
-        if thread_control["run_thread"].is_alive():
-            thread_control["run_thread"].terminate()
+        thread_control["run_thread"].terminate()
+        thread_control["run_thread"].join()
         thread_control["run_thread"] = None
 
-def start_process(q, fig_queue, settings_type='mask'):
+def start_process_v1(q, fig_queue, settings_type='mask'):
     global thread_control, vars_dict
-    from .settings import check_settings
+    from .settings import check_settings, expected_types
 
-    settings = check_settings(vars_dict)
+    settings = check_settings(vars_dict, expected_types, q)
     if thread_control.get("run_thread") is not None:
         initiate_abort()
     stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
@@ -68,9 +67,47 @@ def start_process(q, fig_queue, settings_type='mask'):
         thread_control["run_thread"] = Process(target=run_umap_gui, args=(settings, q, fig_queue, stop_requested))
     thread_control["run_thread"].start()
 
-def import_settings(settings_type='mask'):
+def start_process(q=None, fig_queue=None, settings_type='mask'):
+    global thread_control, vars_dict
+    from .settings import check_settings, expected_types
 
-    global vars_dict, scrollable_frame
+    if q is None:
+        q = Queue()
+    if fig_queue is None:
+        fig_queue = Queue()
+
+    try:
+        settings = check_settings(vars_dict, expected_types, q)
+    except ValueError as e:
+        q.put(f"Error: {e}")
+        return
+
+    if thread_control.get("run_thread") is not None:
+        initiate_abort()
+    
+    stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
+    thread_control["stop_requested"] = stop_requested
+
+    process_args = (settings, q, fig_queue, stop_requested)
+
+    if settings_type == 'mask':
+        thread_control["run_thread"] = Process(target=run_mask_gui, args=process_args)
+    elif settings_type == 'measure':
+        thread_control["run_thread"] = Process(target=run_measure_gui, args=process_args)
+    elif settings_type == 'classify':
+        thread_control["run_thread"] = Process(target=run_classify_gui, args=process_args)
+    elif settings_type == 'sequencing':
+        thread_control["run_thread"] = Process(target=run_sequencing_gui, args=process_args)
+    elif settings_type == 'umap':
+        thread_control["run_thread"] = Process(target=run_umap_gui, args=process_args)
+    else:
+        q.put(f"Error: Unknown settings type '{settings_type}'")
+        return
+
+    thread_control["run_thread"].start()
+
+def import_settings(settings_type='mask'):
+    global vars_dict, scrollable_frame, button_scrollable_frame
     from .settings import generate_fields
 
     def read_settings_from_csv(csv_file_path):
@@ -98,6 +135,7 @@ def import_settings(settings_type='mask'):
     if not csv_file_path:  # If no file is selected, return early
         return
     
+    #vars_dict = hide_all_settings(vars_dict, categories=None)
     csv_settings = read_settings_from_csv(csv_file_path)
     if settings_type == 'mask':
         settings = set_default_settings_preprocess_generate_masks(src='path', settings={})
@@ -115,6 +153,7 @@ def import_settings(settings_type='mask'):
     variables = convert_settings_dict_for_gui(settings)
     new_settings = update_settings_from_csv(variables, csv_settings)
     vars_dict = generate_fields(new_settings, scrollable_frame)
+    vars_dict = hide_all_settings(vars_dict, categories=None)
 
 def convert_settings_dict_for_gui(settings):
     variables = {}
@@ -314,9 +353,8 @@ def download_dataset(repo_id, subfolder, local_dir=None, retries=5, delay=5):
 
     raise Exception("Failed to download files after multiple attempts.")
 
-
 def setup_button_section(horizontal_container, settings_type='mask', settings_row=5, run=True, abort=True, download=True, import_btn=True):
-    global button_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict
+    global button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict
 
     button_frame = tk.Frame(horizontal_container, bg='black')
     horizontal_container.add(button_frame, stretch="always", sticky="nsew")
@@ -357,60 +395,29 @@ def setup_button_section(horizontal_container, settings_type='mask', settings_ro
         toggle_settings(button_scrollable_frame)
     return button_scrollable_frame
 
-def toggle_settings_v1(button_scrollable_frame):
-    global vars_dict
-    from .settings import categories
-
-    if vars_dict is None:
-        raise ValueError("vars_dict is not initialized.")
+def hide_all_settings(vars_dict, categories):
+    """
+    Function to initially hide all settings in the GUI.
 
-    def toggle_category(settings, var):
-        for setting in settings:
-            if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
-                if var.get() == 0:
-                    label.grid_remove()
-                    widget.grid_remove()
-                else:
-                    label.grid()
-                    widget.grid()
+    Parameters:
+    - categories: dict, The categories of settings with their corresponding settings.
+    - vars_dict: dict, The dictionary containing the settings and their corresponding widgets.
+    """
 
-    row = 1
-    col = 3 
-    category_idx = 0
+    if categories is None:
+        from .settings import categories
 
     for category, settings in categories.items():
         if any(setting in vars_dict for setting in settings):
-            category_var = tk.IntVar(value=0)
-            vars_dict[category] = (None, None, category_var)
-            toggle = spacrCheckbutton(
-                button_scrollable_frame.scrollable_frame, 
-                text=category, 
-                variable=category_var, 
-                command=lambda cat=settings, var=category_var: toggle_category(cat, var)
-            )
-            # Directly set the style
-            style = ttk.Style()
-            font_style = tkFont.Font(family="Helvetica", size=12, weight="bold")
-            style.configure('Spacr.TCheckbutton', font=font_style, background='black', foreground='#ffffff', indicatoron=False, relief='flat')
-            style.map('Spacr.TCheckbutton', background=[('selected', 'black'), ('active', 'black')], foreground=[('selected', '#ffffff'), ('active', '#ffffff')])
-            toggle.configure(style='Spacr.TCheckbutton')
-            toggle.grid(row=row, column=col, sticky="w", pady=2, padx=2)
-            #row += 1
-            col += 1
-            category_idx += 1
-
-            if category_idx % 4 == 0:  
-                row += 1
-                col = 2
-
-    for settings in categories.values():
-        for setting in settings:
-            if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
-                label.grid_remove()
-                widget.grid_remove()
-
+            vars_dict[category] = (None, None, tk.IntVar(value=0))
+            
+            # Initially hide all settings
+            for setting in settings:
+                if setting in vars_dict:
+                    label, widget, _ = vars_dict[setting]
+                    label.grid_remove()
+                    widget.grid_remove()
+    return vars_dict
 
 def toggle_settings(button_scrollable_frame):
     global vars_dict
@@ -449,16 +456,7 @@ def toggle_settings(button_scrollable_frame):
     non_empty_categories = [category for category, settings in categories.items() if any(setting in vars_dict for setting in settings)]
     category_dropdown = spacrDropdownMenu(button_scrollable_frame.scrollable_frame, category_var, non_empty_categories, command=on_category_select)
     category_dropdown.grid(row=1, column=3, sticky="ew", pady=2, padx=2)
-
-    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))
-            # Initially hide all settings
-            for setting in settings:
-                if setting in vars_dict:
-                    label, widget, _ = vars_dict[setting]
-                    label.grid_remove()
-                    widget.grid_remove()
+    vars_dict = hide_all_settings(vars_dict, categories)
 
 def process_fig_queue():
     global canvas, fig_queue, canvas_widget, parent_frame
@@ -532,6 +530,8 @@ def setup_frame(parent_frame):
 
 def initiate_root(parent, settings_type='mask'):
 
+    set_start_method('spawn', force=True)
+
     def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
         try:
             ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')

spacr/gui_elements.py

@@ -101,9 +101,11 @@ class spacrButton(tk.Frame):
         super().__init__(parent, *args, **kwargs)
         self.text = text
         self.command = command
-        screen_height = self.winfo_screenheight()
-        button_height = screen_height // 50
-        button_width = button_height * 3
+        #screen_height = self.winfo_screenheight()
+        button_height = 50 #screen_height // 50
+        button_width = 140 #button_height * 3
+
+        #print(button_height, button_width)
 
         # Increase the canvas size to accommodate the button and the rim
         self.canvas = tk.Canvas(self, width=button_width + 4, height=button_height + 4, highlightthickness=0, bg="black")
@@ -294,8 +296,8 @@ def create_menu_bar(root):
 def set_dark_style(style):
     font_style = tkFont.Font(family="Helvetica", size=24)
     style.configure('TEntry', padding='5 5 5 5', borderwidth=1, relief='solid', fieldbackground='black', foreground='#ffffff', font=font_style)
-    style.configure('TCombobox', fieldbackground='black', background='black', foreground='#ffffff', font=font_style)
-    style.map('TCombobox', fieldbackground=[('readonly', 'black')], foreground=[('readonly', '#ffffff')])
+    style.configure('TCombobox', fieldbackground='black', background='black', foreground='#ffffff', selectbackground='black', selectforeground='#ffffff', font=font_style)
+    style.map('TCombobox', fieldbackground=[('readonly', 'black')], foreground=[('readonly', '#ffffff')], selectbackground=[('readonly', 'black')], selectforeground=[('readonly', '#ffffff')])
     style.configure('Custom.TButton', background='black', foreground='white', bordercolor='white', focusthickness=3, focuscolor='white', font=('Helvetica', 12))
     style.map('Custom.TButton', background=[('active', 'teal'), ('!active', 'black')], foreground=[('active', 'white'), ('!active', 'white')], bordercolor=[('active', 'white'), ('!active', 'white')])
     style.configure('Custom.TLabel', padding='5 5 5 5', borderwidth=1, relief='flat', background='black', foreground='#ffffff', font=font_style)

spacr/gui_utils.py

@@ -68,7 +68,7 @@ def load_app(root, app_name, app_func):
     else:
         proceed_with_app(root, app_name, app_func)
 
-def parse_list(value):
+def parse_list_v1(value):
     try:
         parsed_value = ast.literal_eval(value)
         if isinstance(parsed_value, list):
@@ -78,6 +78,16 @@ def parse_list(value):
     except (ValueError, SyntaxError):
         raise ValueError("Invalid format for list")
     
+def parse_list(value):
+    try:
+        parsed_value = ast.literal_eval(value)
+        if isinstance(parsed_value, list):
+            return parsed_value
+        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}")
+    
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
     label_column = 0
     widget_column = 1

spacr/gui_wrappers.py

@@ -4,15 +4,27 @@ matplotlib.use('Agg')
 
 fig_queue = None
 
-def my_show():
+def spacrFigShow_v1():
     """
     Replacement for plt.show() that queues figures instead of displaying them.
     """
+    global fig_queue
     fig = plt.gcf()
     fig_queue.put(fig)
     plt.close(fig)
 
-def measure_crop_wrapper(settings, q, fig_queue):
+def spacrFigShow(fig_queue=None):
+    """
+    Replacement for plt.show() that queues figures instead of displaying them.
+    """
+    fig = plt.gcf()
+    if fig_queue:
+        fig_queue.put(fig)
+    else:
+        fig.show()
+    plt.close(fig)
+
+def preprocess_generate_masks_wrapper(settings, q, fig_queue):
     """
     Wraps the measure_crop function to integrate with GUI processes.
     
@@ -24,19 +36,18 @@ def measure_crop_wrapper(settings, q, fig_queue):
 
     # Temporarily override plt.show
     original_show = plt.show
-    plt.show = my_show
+    plt.show = lambda: spacrFigShow(fig_queue)
 
     try:
-        print('start')
-        spacr.measure.measure_crop(settings=settings)
+        spacr.core.preprocess_generate_masks(src=settings['src'], settings=settings)
     except Exception as e:
         errorMessage = f"Error during processing: {e}"
         q.put(errorMessage)
         traceback.print_exc()
     finally:
-        plt.show = original_show  
-        
-def preprocess_generate_masks_wrapper(settings, q, fig_queue):
+        plt.show = original_show
+
+def measure_crop_wrapper(settings, q, fig_queue):
     """
     Wraps the measure_crop function to integrate with GUI processes.
     
@@ -48,22 +59,23 @@ def preprocess_generate_masks_wrapper(settings, q, fig_queue):
 
     # Temporarily override plt.show
     original_show = plt.show
-    plt.show = my_show
+    plt.show = lambda: spacrFigShow(fig_queue)
 
     try:
-        spacr.core.preprocess_generate_masks(src=settings['src'], settings=settings)
+        print('start')
+        spacr.measure.measure_crop(settings=settings)
     except Exception as e:
         errorMessage = f"Error during processing: {e}"
         q.put(errorMessage)
         traceback.print_exc()
     finally:
-        plt.show = original_show
+        plt.show = original_show  
 
 def sequencing_wrapper(settings, q, fig_queue):
 
     # Temporarily override plt.show
     original_show = plt.show
-    plt.show = my_show
+    plt.show = lambda: spacrFigShow(fig_queue)
 
     try:
         spacr.sequencing.analyze_reads(settings=settings)
@@ -78,7 +90,7 @@ def umap_wrapper(settings, q, fig_queue):
 
     # Temporarily override plt.show
     original_show = plt.show
-    plt.show = my_show
+    plt.show = lambda: spacrFigShow(fig_queue)
 
     try:
         spacr.core.generate_image_umap(settings=settings)
@@ -101,7 +113,7 @@ def train_test_model_wrapper(settings, q, fig_queue):
 
     # Temporarily override plt.show
     original_show = plt.show
-    plt.show = my_show
+    plt.show = lambda: spacrFigShow(fig_queue)
 
     try:
         spacr.core.train_test_model(settings['src'], settings=settings)
@@ -125,7 +137,7 @@ def run_multiple_simulations_wrapper(settings, q, fig_queue):
 
     # Temporarily override plt.show
     original_show = plt.show
-    plt.show = my_show
+    plt.show = lambda: spacrFigShow(fig_queue)
 
     try:
         spacr.sim.run_multiple_simulations(settings=settings)