spacr 0.2.45__py3-none-any.whl → 0.2.53__py3-none-any.whl

spacr/resources/font/open_sans/README.txt

@@ -0,0 +1,100 @@
+Open Sans Variable Font
+=======================
+
+This download contains Open Sans as both variable fonts and static fonts.
+
+Open Sans is a variable font with these axes:
+  wdth
+  wght
+
+This means all the styles are contained in these files:
+  OpenSans-VariableFont_wdth,wght.ttf
+  OpenSans-Italic-VariableFont_wdth,wght.ttf
+
+If your app fully supports variable fonts, you can now pick intermediate styles
+that aren’t available as static fonts. Not all apps support variable fonts, and
+in those cases you can use the static font files for Open Sans:
+  static/OpenSans_Condensed-Light.ttf
+  static/OpenSans_Condensed-Regular.ttf
+  static/OpenSans_Condensed-Medium.ttf
+  static/OpenSans_Condensed-SemiBold.ttf
+  static/OpenSans_Condensed-Bold.ttf
+  static/OpenSans_Condensed-ExtraBold.ttf
+  static/OpenSans_SemiCondensed-Light.ttf
+  static/OpenSans_SemiCondensed-Regular.ttf
+  static/OpenSans_SemiCondensed-Medium.ttf
+  static/OpenSans_SemiCondensed-SemiBold.ttf
+  static/OpenSans_SemiCondensed-Bold.ttf
+  static/OpenSans_SemiCondensed-ExtraBold.ttf
+  static/OpenSans-Light.ttf
+  static/OpenSans-Regular.ttf
+  static/OpenSans-Medium.ttf
+  static/OpenSans-SemiBold.ttf
+  static/OpenSans-Bold.ttf
+  static/OpenSans-ExtraBold.ttf
+  static/OpenSans_Condensed-LightItalic.ttf
+  static/OpenSans_Condensed-Italic.ttf
+  static/OpenSans_Condensed-MediumItalic.ttf
+  static/OpenSans_Condensed-SemiBoldItalic.ttf
+  static/OpenSans_Condensed-BoldItalic.ttf
+  static/OpenSans_Condensed-ExtraBoldItalic.ttf
+  static/OpenSans_SemiCondensed-LightItalic.ttf
+  static/OpenSans_SemiCondensed-Italic.ttf
+  static/OpenSans_SemiCondensed-MediumItalic.ttf
+  static/OpenSans_SemiCondensed-SemiBoldItalic.ttf
+  static/OpenSans_SemiCondensed-BoldItalic.ttf
+  static/OpenSans_SemiCondensed-ExtraBoldItalic.ttf
+  static/OpenSans-LightItalic.ttf
+  static/OpenSans-Italic.ttf
+  static/OpenSans-MediumItalic.ttf
+  static/OpenSans-SemiBoldItalic.ttf
+  static/OpenSans-BoldItalic.ttf
+  static/OpenSans-ExtraBoldItalic.ttf
+
+Get started
+-----------
+
+1. Install the font files you want to use
+
+2. Use your app's font picker to view the font family and all the
+available styles
+
+Learn more about variable fonts
+-------------------------------
+
+  https://developers.google.com/web/fundamentals/design-and-ux/typography/variable-fonts
+  https://variablefonts.typenetwork.com
+  https://medium.com/variable-fonts
+
+In desktop apps
+
+  https://theblog.adobe.com/can-variable-fonts-illustrator-cc
+  https://helpx.adobe.com/nz/photoshop/using/fonts.html#variable_fonts
+
+Online
+
+  https://developers.google.com/fonts/docs/getting_started
+  https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Fonts/Variable_Fonts_Guide
+  https://developer.microsoft.com/en-us/microsoft-edge/testdrive/demos/variable-fonts
+
+Installing fonts
+
+  MacOS: https://support.apple.com/en-us/HT201749
+  Linux: https://www.google.com/search?q=how+to+install+a+font+on+gnu%2Blinux
+  Windows: https://support.microsoft.com/en-us/help/314960/how-to-install-or-remove-a-font-in-windows
+
+Android Apps
+
+  https://developers.google.com/fonts/docs/android
+  https://developer.android.com/guide/topics/ui/look-and-feel/downloadable-fonts
+
+License
+-------
+Please read the full license text (OFL.txt) to understand the permissions,
+restrictions and requirements for usage, redistribution, and modification.
+
+You can use them in your products & projects – print or digital,
+commercial or otherwise.
+
+This isn't legal advice, please consider consulting a lawyer and see the full
+license for all details.

spacr/sequencing.py

@@ -1,4 +1,4 @@
-import os, gc, gzip, re, time, math, subprocess
+import os, gc, gzip, re, time, math, subprocess, traceback
 import pandas as pd
 import numpy as np
 from tqdm import tqdm
@@ -21,6 +21,96 @@ from sklearn.preprocessing import FunctionTransformer, MinMaxScaler
 from scipy.stats import shapiro
 from patsy import dmatrices
 
+import os
+import gzip
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+def consensus_sequence(fastq_r1, fastq_r2, output_file, chunk_size=1000000):
+
+    total_reads = 0
+    chunk_count = 0
+    
+    with gzip.open(fastq_r1, "rt") as r1_handle, gzip.open(fastq_r2, "rt") as r2_handle, gzip.open(output_file, "wt") as output_handle:
+        r1_iter = SeqIO.parse(r1_handle, "fastq")
+        r2_iter = SeqIO.parse(r2_handle, "fastq")
+        
+        while True:
+            r1_chunk = [rec for rec in (next(r1_iter, None) for _ in range(chunk_size)) if rec is not None]
+            r2_chunk = [rec for rec in (next(r2_iter, None) for _ in range(chunk_size)) if rec is not None]
+            
+            # If either chunk is empty, we have reached the end of one or both files
+            if not r1_chunk or not r2_chunk:
+                break
+            
+            chunk_count += 1
+            total_reads += len(r1_chunk)
+            
+            for r1_record, r2_record in zip(r1_chunk, r2_chunk):
+                best_sequence = []
+                best_quality = []
+                for base1, base2, qual1, qual2 in zip(r1_record.seq, r2_record.seq, r1_record.letter_annotations["phred_quality"], r2_record.letter_annotations["phred_quality"]):
+                    if qual1 >= qual2:
+                        best_sequence.append(base1)
+                        best_quality.append(qual1)
+                    else:
+                        best_sequence.append(base2)
+                        best_quality.append(qual2)
+                
+                consensus_seq = Seq("".join(best_sequence))
+                
+                # Create a new SeqRecord for the consensus sequence
+                consensus_record = SeqRecord(consensus_seq, id=r1_record.id, description="", letter_annotations={"phred_quality": best_quality})
+                
+                # Write the consensus sequence to the output file
+                SeqIO.write(consensus_record, output_handle, "fastq")
+            
+            print(f"Progress: Chunk {chunk_count} with {total_reads} reads.")
+            
+def parse_gz_files(folder_path):
+    """
+    Parses the .fastq.gz files in the specified folder path and returns a dictionary
+    containing the sample names and their corresponding file paths.
+
+    Args:
+        folder_path (str): The path to the folder containing the .fastq.gz files.
+
+    Returns:
+        dict: A dictionary where the keys are the sample names and the values are
+        dictionaries containing the file paths for the 'R1' and 'R2' read directions.
+    """
+    files = os.listdir(folder_path)
+    gz_files = [f for f in files if f.endswith('.fastq.gz')]
+
+    samples_dict = {}
+    for gz_file in gz_files:
+        parts = gz_file.split('_')
+        sample_name = parts[0]
+        read_direction = parts[1]
+
+        if sample_name not in samples_dict:
+            samples_dict[sample_name] = {}
+
+        if read_direction == "R1":
+            samples_dict[sample_name]['R1'] = os.path.join(folder_path, gz_file)
+        elif read_direction == "R2":
+            samples_dict[sample_name]['R2'] = os.path.join(folder_path, gz_file)
+
+    return samples_dict
+
+def generate_consensus_sequence(src, chunk_size):
+    samples_dict = parse_gz_files(src)
+    for key in samples_dict:
+        if samples_dict[key]['R1'] and samples_dict[key]['R2']:
+            R1 = samples_dict[key]['R1']
+            R2 = samples_dict[key]['R2']
+            consensus_dir = os.path.join(os.path.dirname(R1), 'consensus')
+            os.makedirs(consensus_dir, exist_ok=True)  # Use os.makedirs() instead of os.mkdir()
+            consensus = os.path.join(consensus_dir, f"{key}_consensus.fastq.gz")
+            consensus_sequence(R1, R2, consensus, chunk_size)
+
+
 def analyze_reads(settings):
     """
     Analyzes reads from gzipped fastq files and combines them based on specified settings.
@@ -291,12 +381,15 @@ def analyze_reads(settings):
                 qc_df.to_csv(qc_file_path, index=False)
                 
     from .settings import get_analyze_reads_default_settings
-
-    settings = get_analyze_reads_default_settings(settings)
-
-    samples_dict = parse_gz_files(settings['src'])
-    combine_reads(samples_dict, settings['src'], settings['chunk_size'], settings['barecode_length_1'], settings['barecode_length_2'], settings['upstream'], settings['downstream'])
-
+    try:
+        settings = get_analyze_reads_default_settings(settings)
+        samples_dict = parse_gz_files(settings['src'])
+        combine_reads(samples_dict, settings['src'], settings['chunk_size'], settings['barecode_length_1'], settings['barecode_length_2'], settings['upstream'], settings['downstream'])
+    except Exception as e:
+        print(e)
+        Error = traceback.format_exc()
+        print(Error)
+    
 def map_barcodes(h5_file_path, settings={}):
     """
     Maps barcodes and performs quality control on sequencing data.
@@ -461,9 +554,7 @@ def map_barcodes(h5_file_path, settings={}):
         return filtered_df
     
     from .settings import get_map_barcodes_default_settings
-
     settings = get_map_barcodes_default_settings(settings)
-
     fldr = os.path.splitext(h5_file_path)[0]
     file_name = os.path.basename(fldr)
 
@@ -729,7 +820,12 @@ def grna_plate_heatmap(path, specific_grna=None, min_max='all', cmap='viridis',
     
     return fig
 
-def map_barcodes_folder(src, settings={}):
+def map_barcodes_folder(settings={}):
+    from .settings import get_map_barcodes_default_settings
+    settings = get_map_barcodes_default_settings(settings)
+
+    print(settings)
+    src = settings['src']
     for file in os.listdir(src):
         if file.endswith('.h5'):
             print(file)
@@ -1846,6 +1942,4 @@ def perform_regression(df, settings):
 
     print('Significant Genes')
     display(significant)
-    return coef_df
-
-
+    return coef_df

spacr/settings.py

@@ -220,6 +220,7 @@ def get_measure_crop_settings(settings):
 
     settings.setdefault('src', 'path')
     settings.setdefault('verbose', False)
+    settings.setdefault('experiment', 'exp')
     
     # Test mode
     settings.setdefault('test_mode', False)
@@ -252,8 +253,6 @@ def get_measure_crop_settings(settings):
 
     # Operational settings
     settings.setdefault('plot',False)
-    settings.setdefault('plot_filtration',False)
-    settings.setdefault('representative_images', False)
     settings.setdefault('n_jobs', os.cpu_count()-2)
 
     # Object settings
@@ -268,24 +267,9 @@ def get_measure_crop_settings(settings):
     settings.setdefault('cytoplasm_min_size',0)
     settings.setdefault('merge_edge_pathogen_cells', True)
 
-    # Miscellaneous settings
-    settings.setdefault('experiment', 'exp')
-    settings.setdefault('cells', ['HeLa'])
-    settings.setdefault('cell_loc', None)
-    settings.setdefault('pathogens', ['ME49Dku80WT', 'ME49Dku80dgra8:GRA8', 'ME49Dku80dgra8', 'ME49Dku80TKO'])
-    settings.setdefault('pathogen_loc', [['c1', 'c2', 'c3', 'c4', 'c5', 'c6'], ['c7', 'c8', 'c9', 'c10', 'c11', 'c12'], ['c13', 'c14', 'c15', 'c16', 'c17', 'c18'], ['c19', 'c20', 'c21', 'c22', 'c23', 'c24']])
-    settings.setdefault('treatments', ['BR1', 'BR2', 'BR3'])
-    settings.setdefault('treatment_loc', [['c1', 'c2', 'c7', 'c8', 'c13', 'c14', 'c19', 'c20'], ['c3', 'c4', 'c9', 'c10', 'c15', 'c16', 'c21', 'c22'], ['c5', 'c6', 'c11', 'c12', 'c17', 'c18', 'c23', 'c24']])
-    settings.setdefault('channel_of_interest', 2)
-    settings.setdefault('compartments', ['pathogen', 'cytoplasm'])
-    settings.setdefault('measurement', 'mean_intensity')
-    settings.setdefault('nr_imgs', 32)
-    settings.setdefault('um_per_pixel', 0.1)
-
     if settings['test_mode']:
         settings['verbose'] = True
         settings['plot'] = True
-        settings['plot_filtration'] = True
         test_imgs = settings['test_nr']
         print(f'Test mode enabled with {test_imgs} images, plotting set to True')
 
@@ -384,6 +368,7 @@ def get_analyze_recruitment_default_settings(settings):
     return settings
 
 def get_analyze_reads_default_settings(settings):
+    settings.setdefault('src', 'path')
     settings.setdefault('upstream', 'CTTCTGGTAAATGGGGATGTCAAGTT') 
     settings.setdefault('downstream', 'GTTTAAGAGCTATGCTGGAAACAGCAG') #This is the reverce compliment of the column primer starting from the end #TGCTGTTTAAGAGCTATGCTGGAAACAGCA
     settings.setdefault('barecode_length_1', 8)
@@ -396,7 +381,7 @@ def get_map_barcodes_default_settings(settings):
     settings.setdefault('src', 'path')
     settings.setdefault('grna', '/home/carruthers/Documents/grna_barcodes.csv')
     settings.setdefault('barcodes', '/home/carruthers/Documents/SCREEN_BARCODES.csv')
-    settings.setdefault('plate_dict', {'EO1': 'plate1', 'EO2': 'plate2', 'EO3': 'plate3', 'EO4': 'plate4', 'EO5': 'plate5', 'EO6': 'plate6', 'EO7': 'plate7', 'EO8': 'plate8'})
+    settings.setdefault('plate_dict', "{'EO1': 'plate1', 'EO2': 'plate2', 'EO3': 'plate3', 'EO4': 'plate4', 'EO5': 'plate5', 'EO6': 'plate6', 'EO7': 'plate7', 'EO8': 'plate8'}")
     settings.setdefault('test', False)
     settings.setdefault('verbose', True)
     settings.setdefault('pc', 'TGGT1_220950_1')
@@ -554,8 +539,6 @@ expected_types = {
     "png_dims": list,
     "normalize_by": str,
     "save_measurements": bool,
-    "representative_images": bool,
-    "plot_filtration": bool,
     "include_uninfected": bool,
     "dialate_pngs": bool,
     "dialate_png_ratios": list,
@@ -742,60 +725,6 @@ expected_types = {
     "fraction_threshold": float,
 }
 
-def check_settings_v1(vars_dict, expected_types,q=None):
-    from .gui_utils import parse_list
-    settings = {}
-    # Define the expected types for each key, including None where applicable
-
-    for key, (label, widget, var) in vars_dict.items():
-        if key not in expected_types:
-            if key not in ["General","Nucleus","Cell","Pathogen","Timelapse","Plot","Object Image","Annotate Data","Measurements","Advanced","Miscellaneous","Test"]:
-                q.put(f"Key {key} not found in expected types.")
-                continue
-
-        value = var.get()
-        expected_type = expected_types.get(key, str)
-
-        try:
-            if key in ["png_size", "pathogen_plate_metadata", "treatment_plate_metadata"]:
-                parsed_value = ast.literal_eval(value) if value else None
-                if isinstance(parsed_value, list):
-                    if all(isinstance(i, list) for i in parsed_value) or all(not isinstance(i, list) for i in parsed_value):
-                        settings[key] = parsed_value
-                    else:
-                        raise ValueError("Invalid format: Mixed list and list of lists")
-                else:
-                    raise ValueError("Invalid format for list or list of lists")
-            elif expected_type == list:
-                settings[key] = parse_list(value) if value else None
-            elif expected_type == bool:
-                settings[key] = value if isinstance(value, bool) else value.lower() in ['true', '1', 't', 'y', 'yes']
-            elif expected_type == (int, type(None)):
-                settings[key] = int(value) if value else None
-            elif expected_type == (float, type(None)):
-                settings[key] = float(value) if value else None
-            elif expected_type == (int, float):
-                settings[key] = float(value) if '.' in value else int(value)
-            elif expected_type == (str, type(None)):
-                settings[key] = str(value) if value else None
-            elif isinstance(expected_type, tuple):
-                for typ in expected_type:
-                    try:
-                        settings[key] = typ(value) if value else None
-                        break
-                    except (ValueError, TypeError):
-                        continue
-                else:
-                    raise ValueError
-            else:
-                settings[key] = expected_type(value) if value else None
-        except (ValueError, SyntaxError):
-            expected_type_name = ' or '.join([t.__name__ for t in expected_type]) if isinstance(expected_type, tuple) else expected_type.__name__
-            q.put(f"Error: Invalid format for {key}. Expected type: {expected_type_name}.")
-            return
-
-    return settings
-
 def check_settings(vars_dict, expected_types, q=None):
     from .gui_utils import parse_list
 
@@ -805,9 +734,9 @@ def check_settings(vars_dict, expected_types, q=None):
 
     settings = {}
 
-    for key, (label, widget, var) in vars_dict.items():
+    for key, (label, widget, var, _) in vars_dict.items():
         if key not in expected_types:
-            if key not in ["General", "Nucleus", "Cell", "Pathogen", "Timelapse", "Plot", "Object Image", "Annotate Data", "Measurements", "Advanced", "Miscellaneous", "Test"]:
+            if key not in ["General", "Nucleus", "Cell", "Pathogen", "Timelapse", "Plot", "Object Image", "Annotate Data", "Measurements", "Advanced", "Miscellaneous", "Test", "Paths"]:
                 q.put(f"Key {key} not found in expected types.")
                 continue
 
@@ -836,6 +765,20 @@ def check_settings(vars_dict, expected_types, q=None):
                 settings[key] = float(value) if '.' in value else int(value)
             elif expected_type == (str, type(None)):
                 settings[key] = str(value) if value else None
+            elif expected_type == dict:
+                try:
+                    # Ensure that the value is a string that can be converted to a dictionary
+                    if isinstance(value, str):
+                        settings[key] = ast.literal_eval(value)
+                    else:
+                        raise ValueError("Expected a string representation of a dictionary.")
+                    
+                    # Check if the result is actually a dictionary
+                    if not isinstance(settings[key], dict):
+                        raise ValueError("Value is not a valid dictionary.")
+                except (ValueError, SyntaxError) as e:
+                    settings[key] = {}
+                    q.put(f"Error: Invalid format for {key}. Expected type: dict. Error: {e}")
             elif isinstance(expected_type, tuple):
                 for typ in expected_type:
                     try:
@@ -856,7 +799,7 @@ def check_settings(vars_dict, expected_types, q=None):
 
 def generate_fields(variables, scrollable_frame):
     from .gui_utils import create_input_field
-    from .gui_elements import spacrToolTip
+    from .gui_elements import set_dark_style, spacrToolTip
     row = 1
     vars_dict = {}
     tooltips = {
@@ -1014,7 +957,6 @@ def generate_fields(variables, scrollable_frame):
         "plot_by_cluster": "(bool) - Whether to plot images by clusters.",
         "plot_cluster_grids": "(bool) - Whether to plot grids of clustered images.",
         "plot_control": "(dict) - Control settings for plotting.",
-        "plot_filtration": "(bool) - Whether to plot the filtration steps.",
         "plot_images": "(bool) - Whether to plot images.",
         "plot_nr": "(int) - Number of plots to generate.",
         "plot_outlines": "(bool) - Whether to plot outlines of segmented objects.",
@@ -1036,7 +978,6 @@ def generate_fields(variables, scrollable_frame):
         "remove_image_canvas": "(bool) - Whether to remove the image canvas after plotting.",
         "remove_low_variance_features": "(bool) - Whether to remove low variance features from the analysis.",
         "remove_row_column_effect": "(bool) - Whether to remove row and column effects from the data.",
-        "representative_images": "(bool) - Whether to save representative images of the segmented objects (Not working yet).",
         "resize": "(bool) - Resize factor for the images.",
         "resample": "(bool) - Whether to resample the images during processing.",
         "rescale": "(float) - Rescaling factor for the images.",
@@ -1080,17 +1021,19 @@ def generate_fields(variables, scrollable_frame):
         "um_per_pixel": "(float) - The micrometers per pixel for the images."
     }
 
-
     for key, (var_type, options, default_value) in variables.items():
-        label, widget, var = create_input_field(scrollable_frame.scrollable_frame, key, row, var_type, options, default_value)
-        vars_dict[key] = (label, widget, var)  # Store the label, widget, and variable
+        label, widget, var, frame = create_input_field(scrollable_frame.scrollable_frame, key, row, var_type, options, default_value)
+        vars_dict[key] = (label, widget, var, frame)  # Store the label, widget, and variable
         
         # Add tooltip to the label if it exists in the tooltips dictionary
         if key in tooltips:
             spacrToolTip(label, tooltips[key])
+
         row += 1
+        
     return vars_dict
 
+
 categories = {
     "General": ["src", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims"],
     "Paths":["grna", "barcodes"],
@@ -1100,9 +1043,9 @@ categories = {
     "Cell": ["cell_intensity_range", "cell_size_range", "cell_chann_dim", "cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "include_uninfected", "merge_edge_pathogen_cells", "adjust_cells"],
     "Pathogen": ["pathogen_intensity_range", "pathogen_size_range", "pathogen_chann_dim", "pathogen_channel", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogen_mask_dim"],
     "Timelapse": ["fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
-    "Plot": ["plot_control", "plot_nr", "plot_filtration", "examples_to_plot", "normalize_plots", "normalize", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
+    "Plot": ["plot_control", "plot_nr", "examples_to_plot", "normalize_plots", "normalize", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
     "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "dialate_png_ratios", "crop_mode", "dialate_pngs", "normalize", "use_bounding_box"],
-    "Annotate Data": ["nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","pathogen_types", "pathogen_plate_metadata", "treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "cells", "cell_loc", "pathogens", "pathogen_loc", "channel_of_interest", "measurement", "treatments", "representative_images", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
+    "Annotate Data": ["nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","pathogen_types", "pathogen_plate_metadata", "treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "cells", "cell_loc", "pathogens", "pathogen_loc", "channel_of_interest", "measurement", "treatments", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
     "Measurements": ["remove_image_canvas", "remove_highly_correlated", "homogeneity", "homogeneity_distances", "radial_dist", "calculate_correlation", "manders_thresholds", "save_measurements", "tables", "image_nr", "dot_size", "filter_by", "remove_highly_correlated_features", "remove_low_variance_features", "channel_of_interest"],
     "Advanced": ["plate_dict", "target_intensity_min", "cells_per_well", "include_multinucleated", "include_multiinfected", "include_noninfected", "backgrounds", "plot", "timelapse", "schedule", "test_size","exclude","n_repeats","top_features", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs", "train_mode","amsgrad","use_checkpoint","gradient_accumulation","gradient_accumulation_steps","intermedeate_save","pin_memory","n_jobs","channels","augment"],
     "Clustering": ["eps","min_samples","analyze_clusters","clustering","remove_cluster_noise"],

spacr/utils.py

@@ -1,4 +1,4 @@
-import sys, os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform, signal
+import sys, os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform
 
 import numpy as np
 from cellpose import models as cp_models
@@ -90,9 +90,9 @@ from scipy import stats
 
 def print_progress(files_processed, files_to_process, n_jobs, time_ls=None, batch_size=None, operation_type=""):
     if isinstance(files_processed, list):
-        files_processed = len(files_processed)
+        files_processed = len(set(files_processed))
     if isinstance(files_to_process, list):
-        files_to_process = len(files_to_process)
+        files_to_process = len(set(files_to_process))
     if isinstance(batch_size, list):
         batch_size = len(batch_size)
 
@@ -3628,22 +3628,22 @@ def delete_folder(folder_path):
 def measure_test_mode(settings):    
 
     if settings['test_mode']:
-        if not os.path.basename(settings['input_folder']) == 'test':
-            all_files = os.listdir(settings['input_folder'])
+        if not os.path.basename(settings['src']) == 'test':
+            all_files = os.listdir(settings['src'])
             random_files = random.sample(all_files, settings['test_nr'])
 
-            src = os.path.join(os.path.dirname(settings['input_folder']),'test', 'merged')
+            src = os.path.join(os.path.dirname(settings['src']),'test', 'merged')
             if os.path.exists(src):
                 delete_folder(src)
             os.makedirs(src, exist_ok=True)
 
             for file in random_files:
-                shutil.copy(os.path.join(settings['input_folder'], file), os.path.join(src,file))
+                shutil.copy(os.path.join(settings['src'], file), os.path.join(src,file))
 
-            settings['input_folder'] = src
+            settings['src'] = src
             print(f'Changed source folder to {src} for test mode')
         else:
-            print(f'Test mode enabled, using source folder {settings["input_folder"]}')
+            print(f'Test mode enabled, using source folder {settings["src"]}')
 
     return settings
 

{spacr-0.2.45.dist-info → spacr-0.2.53.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.2.45
+Version: 0.2.53
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -9,9 +9,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 License-File: LICENSE
-Requires-Dist: torch <3.0,>=2.2.1
-Requires-Dist: torchvision <1.0,>=0.17.1
-Requires-Dist: torch-geometric <3.0,>=2.5.1
+Requires-Dist: torch <3.0,>=2.0
+Requires-Dist: torchvision <1.0,>=0.1
+Requires-Dist: torch-geometric <3.0,>=2.5
 Requires-Dist: numpy <2.0,>=1.26.4
 Requires-Dist: pandas <3.0,>=2.2.1
 Requires-Dist: statsmodels <1.0,>=0.14.1
@@ -42,6 +42,8 @@ Requires-Dist: lxml <6.0,>=5.1.0
 Requires-Dist: psutil <6.0,>=5.9.8
 Requires-Dist: gputil <2.0,>=1.4.0
 Requires-Dist: gpustat <2.0,>=1.1.1
+Requires-Dist: pyautogui <1.0,>=0.9.54
+Requires-Dist: tables <4.0,>=3.8.0
 Requires-Dist: huggingface-hub <0.25,>=0.24.0
 Provides-Extra: dev
 Requires-Dist: pytest <3.11,>=3.9 ; extra == 'dev'