spacr 0.3.42__tar.gz → 0.3.43__tar.gz

{spacr-0.3.42/spacr.egg-info → spacr-0.3.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.42
+Version: 0.3.43
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.3.42 → spacr-0.3.43}/setup.py

@@ -67,7 +67,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.3.42",
+    version="0.3.43",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",

{spacr-0.3.42 → spacr-0.3.43}/spacr/cellpose.py

@@ -86,7 +86,6 @@ def identify_masks_finetune(settings):
         if normalize:
             images, _, image_names, _, orig_dims = _load_normalized_images_and_labels(image_files=image_files, label_files=None, channels=channels, percentiles=percentiles,  circular=circular, invert=invert, visualize=verbose, remove_background=remove_background, background=background, Signal_to_noise=Signal_to_noise, target_height=target_height, target_width=target_width)
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
-            #orig_dims = [(image.shape[0], image.shape[1]) for image in images]
         else:
             images, _, image_names, _ = _load_images_and_labels(image_files=image_files, label_files=None, circular=circular, invert=invert) 
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
@@ -126,7 +125,6 @@ def identify_masks_finetune(settings):
             print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls)
             print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="")
             
-            
             if verbose:
                 if resize:
                     stack = resizescikit(stack, dims, preserve_range=True, anti_aliasing=False).astype(stack.dtype)

{spacr-0.3.42 → spacr-0.3.43}/spacr/gui_core.py

@@ -384,8 +384,8 @@ def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
     from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model
     from .settings import set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
-    from .settings import get_default_generate_activation_map_settings
-    #activation
+    from .settings import get_default_generate_activation_map_settings, get_analyze_plaque_settings
+
     def read_settings_from_csv(csv_file_path):
         settings = {}
         with open(csv_file_path, newline='') as csvfile:
@@ -428,7 +428,7 @@ def import_settings(settings_type='mask'):
     elif settings_type == 'activation':
         settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {}
+        settings = get_analyze_plaque_settings(settings={})
     elif settings_type == 'convert':
         settings = {}
     else:
@@ -443,7 +443,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
     from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks
     from .settings import get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
-    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings, get_analyze_plaque_settings
     from .settings import generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_default_generate_activation_map_settings
     from .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
@@ -490,7 +490,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'activation':
         settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {'src':'path to images'}
+        settings = get_analyze_plaque_settings(settings={})
     elif settings_type == 'convert':
         settings = {'src':'path to images'}
     else:

{spacr-0.3.42 → spacr-0.3.43}/spacr/gui_utils.py

@@ -380,7 +380,7 @@ def convert_settings_dict_for_gui(settings):
     variables = {}
     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]'),
+        'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]', '[0,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'], 'metadata'),

{spacr-0.3.42 → spacr-0.3.43}/spacr/io.py

@@ -191,107 +191,130 @@ def _load_images_and_labels(image_files, label_files, circular=False, invert=Fal
         print(f'image shape: {images[0].shape}, image type: images[0].shape mask shape: {labels[0].shape}, image type: labels[0].shape')
     return images, labels, image_names, label_names
 
-def _load_normalized_images_and_labels_v1(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10):
+def _load_normalized_images_and_labels(image_files, label_files, channels=None, percentiles=None,  
+                                       circular=False, invert=False, visualize=False, 
+                                       remove_background=False, background=0, Signal_to_noise=10, 
+                                       target_height=None, target_width=None):
     
-    from .plot import normalize_and_visualize
+    from .plot import normalize_and_visualize, plot_resize
     from .utils import invert_image, apply_mask
+    from skimage.transform import resize as resizescikit
+
+    # Ensure percentiles are valid
+    if isinstance(percentiles, list) and len(percentiles) == 2:
+        try:
+            percentiles = [int(percentiles[0]), int(percentiles[1])]
+        except ValueError:
+            percentiles = None
+    else:
+        percentiles = None
 
-    signal_thresholds = background*Signal_to_noise
+    signal_thresholds = float(background) * float(Signal_to_noise)
     lower_percentile = 2
 
-    images = []
-    labels = []
-    
+    images, labels, orig_dims = [], [], []
     num_channels = 4
     percentiles_1 = [[] for _ in range(num_channels)]
     percentiles_99 = [[] for _ in range(num_channels)]
 
     image_names = [os.path.basename(f) for f in image_files]
-    
+    image_dir = os.path.dirname(image_files[0])
+
     if label_files is not None:
         label_names = [os.path.basename(f) for f in label_files]
         label_dir = os.path.dirname(label_files[0])
+    else:
+        label_names, label_dir = [], None
 
-    # Load images and check percentiles
-    for i,img_file in enumerate(image_files):
+    # Load, normalize, and resize images
+    for i, img_file in enumerate(image_files):
         image = cellpose.io.imread(img_file)
+        orig_dims.append((image.shape[0], image.shape[1]))
+
         if invert:
             image = invert_image(image)
         if circular:
             image = apply_mask(image, output_value=0)
 
-        # If specific channels are specified, select them
+        # Select specific channels if needed
         if channels is not None and image.ndim == 3:
             image = image[..., channels]
 
         if remove_background:
-            image[image < background] = 0
-        
+            image = np.where(image < background, 0, image)
+
         if image.ndim < 3:
             image = np.expand_dims(image, axis=-1)
-        
-        images.append(image)
+
+        # Calculate percentiles if not provided
         if percentiles is None:
             for c in range(image.shape[-1]):
                 p1 = np.percentile(image[..., c], lower_percentile)
                 percentiles_1[c].append(p1)
+
+                # Ensure `signal_thresholds` and `p` are floats for comparison
                 for percentile in [98, 99, 99.9, 99.99, 99.999]:
                     p = np.percentile(image[..., c], percentile)
-                    if p > signal_thresholds:
+                    if float(p) > signal_thresholds:
                         percentiles_99[c].append(p)
                         break
-                    
-    if not percentiles is None:
-        normalized_images = []
-        for image in images:
-            normalized_image = np.zeros_like(image, dtype=np.float32)
-            for c in range(image.shape[-1]):
-                low_p = np.percentile(image[..., c], percentiles[0])
-                high_p = np.percentile(image[..., c], percentiles[1])
-                normalized_image[..., c] = rescale_intensity(image[..., c], in_range=(low_p, high_p), out_range=(0, 1))
-            normalized_images.append(normalized_image)
-            if visualize:
-                normalize_and_visualize(image, normalized_image, title=f"Channel {c+1} Normalized")
-            
+
+        # Resize image if required
+        if target_height and target_width:
+            image_shape = (target_height, target_width) if image.ndim == 2 else (target_height, target_width, image.shape[-1])
+            image = resizescikit(image, image_shape, preserve_range=True, anti_aliasing=True).astype(image.dtype)
+
+        images.append(image)
+
+    # Calculate average percentiles if needed
     if percentiles is None:
-        # Calculate average percentiles for normalization
         avg_p1 = [np.mean(p) for p in percentiles_1]
-        avg_p99 = [np.mean(p) if len(p) > 0 else np.mean(percentiles_1[i]) for i, p in enumerate(percentiles_99)]
+        avg_p99 = [np.mean(p) if p else avg_p1[i] for i, p in enumerate(percentiles_99)]
 
         print(f'Average 1st percentiles: {avg_p1}, Average 99th percentiles: {avg_p99}')
 
-        normalized_images = []
-        for image in images:
-            normalized_image = np.zeros_like(image, dtype=np.float32)
-            for c in range(image.shape[-1]):
-                normalized_image[..., c] = rescale_intensity(image[..., c], in_range=(avg_p1[c], avg_p99[c]), out_range=(0, 1))
-            normalized_images.append(normalized_image)
-            if visualize:
-                normalize_and_visualize(image, normalized_image, title=f"Channel {c+1} Normalized")
-            
-    if not image_files is None:
-        image_dir = os.path.dirname(image_files[0])
+        normalized_images = [
+            np.stack([rescale_intensity(img[..., c], in_range=(avg_p1[c], avg_p99[c]), out_range=(0, 1))
+                      for c in range(img.shape[-1])], axis=-1) for img in images
+        ]
 
     else:
-        image_dir = None
-            
+        normalized_images = [
+            np.stack([rescale_intensity(img[..., c], 
+                                        in_range=(np.percentile(img[..., c], percentiles[0]),
+                                                  np.percentile(img[..., c], percentiles[1])), 
+                                        out_range=(0, 1)) for c in range(img.shape[-1])], axis=-1) 
+            for img in images
+        ]
+
+    # Load and resize labels if provided
     if label_files is not None:
-        for lbl_file in label_files:
-            labels.append(cellpose.io.imread(lbl_file))
-    else:
-        label_names = []
-        label_dir = None
+        labels = [resizescikit(cellpose.io.imread(lbl_file), 
+                               (target_height, target_width) if target_height and target_width else orig_dims[i], 
+                               order=0, preserve_range=True, anti_aliasing=False).astype(np.uint8)
+                  for i, lbl_file in enumerate(label_files)]
 
     print(f'Loaded and normalized {len(normalized_images)} images and {len(labels)} labels from {image_dir} and {label_dir}')
-    
-    return normalized_images, labels, image_names, label_names
 
-def _load_normalized_images_and_labels(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10, target_height=None, target_width=None):
+    if visualize and images and labels:
+        plot_resize(images, normalized_images, labels, labels)
+
+    return normalized_images, labels, image_names, label_names, orig_dims
+
+def _load_normalized_images_and_labels_v1(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10, target_height=None, target_width=None):
     
     from .plot import normalize_and_visualize, plot_resize
     from .utils import invert_image, apply_mask
     from skimage.transform import resize as resizescikit
 
+    if isinstance(percentiles, list):
+        if len(percentiles) !=2:
+            percentiles = None
+        if not percentiles[0] is int:
+            percentiles = None
+        if not percentiles[1] is int:
+            percentiles = None
+    
     signal_thresholds = background * Signal_to_noise
     lower_percentile = 2
 

{spacr-0.3.42 → spacr-0.3.43}/spacr/plot.py

@@ -1521,7 +1521,7 @@ def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True
     return fig
 
 def print_mask_and_flows(stack, mask, flows, overlay=False):
-    fig, axs = plt.subplots(1, 3, figsize=(30, 10))  # Adjust subplot layout
+    fig, axs = plt.subplots(1, 3, figsize=(12, 4))  # Adjust subplot layout
     
     if stack.shape[-1] == 1:
         stack = np.squeeze(stack)

{spacr-0.3.42 → spacr-0.3.43}/spacr/settings.py

@@ -581,6 +581,7 @@ def get_check_cellpose_models_default_settings(settings):
     return settings
 
 def get_identify_masks_finetune_default_settings(settings):
+    settings.setdefault('src', 'path')
     settings.setdefault('model_name', 'cyto')
     settings.setdefault('custom_model', None)
     settings.setdefault('channels', [0,0])
@@ -690,6 +691,7 @@ expected_types = {
     "filter_min_max": (list, type(None)),
     "channel_dims": list,
     "backgrounds": list,
+    "background": str,
     "outline_thickness": int,
     "outline_color": str,
     "overlay_chans": list,
@@ -909,12 +911,12 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Hyperparamiters (Embedding)": ["visualize","n_neighbors","min_dist","metric","resnet_features","reduction_method","embedding_by_controls","col_to_compare","log_data"],
              "Hyperparamiters (Clustering)": ["eps","min_samples","analyze_clusters","clustering","remove_cluster_noise"],
              "Hyperparamiters (Regression)":["cov_type", "class_1_threshold", "plate", "other", "fraction_threshold", "alpha", "random_row_column_effects", "regression_type", "min_cell_count", "agg_type", "transform", "dependent_variable"],
-             "Hyperparamiters (Activation)":["cam_type", "normalize", "overlay", "correlation", "target_layer", "normalize_input"],
+             "Hyperparamiters (Activation)":["cam_type", "overlay", "correlation", "target_layer", "normalize_input"],
              "Annotation": ["nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "channel_of_interest", "measurement", "treatments", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
              "Plot": ["plot", "plot_control", "plot_nr", "examples_to_plot", "normalize_plots", "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"],
              "Test": ["test_mode", "test_images", "random_test", "test_nr", "test", "test_split"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
-             "Advanced": ["shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
+             "Advanced": ["shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "background", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
              "Miscellaneous": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor"]
              }
 
@@ -1367,4 +1369,31 @@ def get_default_generate_activation_map_settings(settings):
     settings.setdefault('manders_thresholds', [15,50, 75])
     settings.setdefault('n_jobs', None)
     
+    return settings
+
+def get_analyze_plaque_settings(settings):
+    settings.setdefault('src', 'path')
+    settings.setdefault('masks', True)
+    settings.setdefault('model_name', 'plaque')
+    settings.setdefault('custom_model', None)
+    settings.setdefault('channels', [0,0])
+    settings.setdefault('background', 200)
+    settings.setdefault('remove_background', False)
+    settings.setdefault('Signal_to_noise', 10)
+    settings.setdefault('CP_prob', 0)
+    settings.setdefault('diameter', 30)
+    settings.setdefault('batch_size', 50)
+    settings.setdefault('flow_threshold', 0.4)
+    settings.setdefault('save', True)
+    settings.setdefault('verbose', True)
+    settings.setdefault('normalize', True)
+    settings.setdefault('percentiles', None)
+    settings.setdefault('circular', False)
+    settings.setdefault('invert', False)
+    settings.setdefault('resize', True)
+    settings.setdefault('target_height', 1120)
+    settings.setdefault('target_width', 1120)
+    settings.setdefault('rescale', False)
+    settings.setdefault('resample', False)
+    settings.setdefault('grayscale', True)
     return settings

{spacr-0.3.42 → spacr-0.3.43}/spacr/submodules.py

@@ -8,6 +8,9 @@ from cellpose import models as cp_models
 from cellpose import train as train_cp
 from IPython.display import display
 
+import matplotlib.pyplot as plt
+from natsort import natsorted
+
 def analyze_recruitment(settings={}):
     """
     Analyze recruitment data by grouping the DataFrame by well coordinates and plotting controls and recruitment data.
@@ -122,7 +125,31 @@ def analyze_recruitment(settings={}):
 
     return [cells,wells]
 
-def analyze_plaques(folder):
+def analyze_plaques(settings):
+
+    from .cellpose import identify_masks_finetune
+    from .settings import get_analyze_plaque_settings
+    from .utils import save_settings, download_models
+    from spacr import __file__ as spacr_path
+
+    download_models()
+    package_dir = os.path.dirname(spacr_path)
+    models_dir = os.path.join(package_dir, 'resources', 'models', 'cp')
+    model_path = os.path.join(models_dir, 'toxo_plaque_cyto_e25000_X1120_Y1120.CP_model')
+    settings['custom_model'] = model_path
+    print('custom_model',settings['custom_model'])
+
+    settings = get_analyze_plaque_settings(settings)
+    save_settings(settings, name='analyze_plaques', show=True)
+
+    if settings['masks']:
+        settings['dst'] = os.path.join(settings['src'], 'masks')
+        display(settings)
+        identify_masks_finetune(settings)
+        folder = settings['dst']
+    else:
+        folder = settings['src']
+
     summary_data = []
     details_data = []
     stats_data = []
@@ -346,4 +373,136 @@ def count_phenotypes(settings):
 
     pivot_df.to_csv(output_path)
 
-    return 
+    return
+
+def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={}, column='column', value='c3', plate='plate1', fraction_threshold=0.05):
+
+    def calculate_well_score_fractions(df, class_columns='cv_predictions'):
+        if all(col in df.columns for col in ['plate', 'row', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        else:
+            raise ValueError("Cannot find 'plate', 'row', or 'column' in df.columns")
+        prc_summary = df.groupby(['plate', 'row', 'column', 'prc']).size().reset_index(name='total_rows')
+        well_counts = (df.groupby(['plate', 'row', 'column', 'prc', class_columns])
+                       .size()
+                       .unstack(fill_value=0)
+                       .reset_index()
+                       .rename(columns={0: 'class_0', 1: 'class_1'}))
+        summary_df = pd.merge(prc_summary, well_counts, on=['plate', 'row', 'column', 'prc'], how='left')
+        summary_df['class_0_fraction'] = summary_df['class_0'] / summary_df['total_rows']
+        summary_df['class_1_fraction'] = summary_df['class_1'] / summary_df['total_rows']
+        return summary_df
+    
+    def plot_line(df, x_column, y_columns, group_column=None, 
+                  xlabel=None, ylabel=None, title=None, figsize=(10, 6), 
+                  save_path=None):
+        """
+        Create a line plot that can handle multiple y-columns, each becoming a separate line.
+        """
+        df = df.loc[natsorted(df.index, key=lambda x: df.loc[x, x_column])]
+
+        plt.figure(figsize=figsize)
+
+        if isinstance(y_columns, list):
+            for y_col in y_columns:
+                sns.lineplot(data=df, x=x_column, y=y_col, label=y_col, marker='o')
+        else:
+            sns.lineplot(data=df, x=x_column, y=y_columns, hue=group_column, marker='o')
+        plt.xlabel(xlabel if xlabel else x_column)
+        plt.ylabel(ylabel if ylabel else 'Value')
+        plt.title(title if title else f'Line Plot')
+        if group_column or isinstance(y_columns, list):
+            plt.legend(title='Legend')
+
+        plt.tight_layout()
+
+        if save_path:
+            plt.savefig(save_path, format='png', dpi=300, bbox_inches='tight')
+            print(f"Plot saved to {save_path}")
+        plt.show()
+    
+    def calculate_grna_fraction_ratio(df, grna1='TGGT1_220950_1', grna2='TGGT1_233460_4'):
+        # Filter relevant grna_names within each prc and group them
+        grouped = df[df['grna_name'].isin([grna1, grna2])] \
+            .groupby(['prc', 'grna_name']) \
+            .agg({'fraction': 'sum', 'count': 'sum'}) \
+            .unstack(fill_value=0)
+        grouped.columns = ['_'.join(col).strip() for col in grouped.columns.values]
+        grouped['fraction_ratio'] = grouped[f'fraction_{grna1}'] / grouped[f'fraction_{grna2}']
+        grouped = grouped.assign(
+            fraction_ratio=lambda x: x['fraction_ratio'].replace([float('inf'), -float('inf')], 0)
+        ).fillna({'fraction_ratio': 0})
+        grouped = grouped.rename(columns={
+            f'count_{grna1}': f'{grna1}_count',
+            f'count_{grna2}': f'{grna2}_count'
+        })
+        result = grouped.reset_index()[['prc', f'{grna1}_count', f'{grna2}_count', 'fraction_ratio']]
+        
+        result['total_reads'] = result[f'{grna1}_count'] + result[f'{grna2}_count']
+        
+        result[f'{grna1}_fraction'] = result[f'{grna1}_count'] / result['total_reads']
+        result[f'{grna2}_fraction'] = result[f'{grna2}_count'] / result['total_reads']
+
+        return result
+
+    def calculate_well_read_fraction(df, count_column='count'):
+        if all(col in df.columns for col in ['plate', 'row', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        else:
+            raise ValueError("Cannot find plate, row or column in df.columns")
+        grouped_df = df.groupby('prc')[count_column].sum().reset_index()
+        grouped_df = grouped_df.rename(columns={count_column: 'total_counts'})
+        df = pd.merge(df, grouped_df, on='prc')
+        df['fraction'] = df['count'] / df['total_counts']
+        return df
+    
+    reads_df = pd.read_csv(reads_csv)
+    scores_df = pd.read_csv(scores_csv)
+    
+    if plate != None:
+        reads_df['plate'] = plate
+        scores_df['plate'] = plate
+    
+    if 'col' in reads_df.columns:
+        reads_df = reads_df.rename(columns={'col': 'column'})
+    if 'column_name' in reads_df.columns:
+        reads_df = reads_df.rename(columns={'column_name': 'column'})
+    if 'col' in scores_df.columns:
+        scores_df = scores_df.rename(columns={'col': 'column'})
+    if 'column_name' in scores_df.columns:
+        scores_df = scores_df.rename(columns={'column_name': 'column'})
+    if 'row_name' in reads_df.columns:
+        reads_df = reads_df.rename(columns={'row_name': 'row'})
+    if 'row_name' in scores_df.columns:
+        scores_df = scores_df.rename(columns={'row_name': 'row'})
+    
+    reads_df = calculate_well_read_fraction(reads_df)
+    scores_df = calculate_well_score_fractions(scores_df)
+    reads_col_df = reads_df[reads_df[column]==value]
+    scores_col_df = scores_df[scores_df[column]==value]
+    
+    #reads_col_df = reads_col_df[reads_col_df['fraction'] >= fraction_threshold]
+    reads_col_df = calculate_grna_fraction_ratio(reads_col_df, grna1='TGGT1_220950_1', grna2='TGGT1_233460_4')
+    df = pd.merge(reads_col_df, scores_col_df, on='prc')
+    
+    
+    # Convert the dictionary to a DataFrame and calculate fractions
+    df_emp = pd.DataFrame(
+        [(key, val[0], val[1], val[0] / (val[0] + val[1]), val[1] / (val[0] + val[1])) 
+         for key, val in empirical_dict.items()],
+        columns=['key', 'value1', 'value2', 'fraction1', 'fraction2']
+    )
+
+    df = pd.merge(df, df_emp, left_on='row', right_on='key')
+    display(df)
+    y_columns = ['class_1_fraction', 'TGGT1_220950_1_fraction', 'fraction2']
+    
+    plot_line(df, x_column='row', y_columns=y_columns, group_column=None, 
+              xlabel=None, ylabel=None, title=None, figsize=(10, 6), 
+              save_path=None)
+    
+    y_columns = ['class_0_fraction', 'TGGT1_233460_4_fraction', 'fraction1']
+
+    plot_line(df, x_column='row', y_columns=y_columns, group_column=None, 
+          xlabel=None, ylabel=None, title=None, figsize=(10, 6), 
+          save_path=None)

{spacr-0.3.42 → spacr-0.3.43}/spacr/utils.py

@@ -64,6 +64,7 @@ from sklearn.decomposition import PCA
 from sklearn.ensemble import RandomForestClassifier
 
 from huggingface_hub import list_repo_files
+from spacr import __file__ as spacr_path
 
 import umap.umap_ as umap
 #import umap
@@ -4963,7 +4964,71 @@ def map_condition(col_value, neg='c1', pos='c2', mix='c3'):
     else:
         return 'screen'
     
-def download_models(repo_id="einarolafsson/models", local_dir=None, retries=5, delay=5):
+def download_models(repo_id="einarolafsson/models", retries=5, delay=5):
+    """
+    Downloads all model files from Hugging Face and stores them in the `resources/models` directory 
+    within the installed `spacr` package.
+
+    Args:
+        repo_id (str): The repository ID on Hugging Face (default is 'einarolafsson/models').
+        retries (int): Number of retry attempts in case of failure.
+        delay (int): Delay in seconds between retries.
+
+    Returns:
+        str: The local path to the downloaded models.
+    """
+    # Construct the path to the `resources/models` directory in the installed `spacr` package
+    package_dir = os.path.dirname(spacr_path)
+    local_dir = os.path.join(package_dir, 'resources', 'models')
+
+    # Create the local directory if it doesn't exist
+    if not os.path.exists(local_dir):
+        os.makedirs(local_dir)
+    elif len(os.listdir(local_dir)) > 0:
+        print(f"Models already downloaded to: {local_dir}")
+        return local_dir
+
+    attempt = 0
+    while attempt < retries:
+        try:
+            # List all files in the repo
+            files = list_repo_files(repo_id, repo_type="dataset")
+            print(f"Files in repository: {files}")  # Debugging print to check file list
+
+            # Download each file
+            for file_name in files:
+                for download_attempt in range(retries):
+                    try:
+                        url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{file_name}?download=true"
+                        print(f"Downloading file from: {url}")  # Debugging
+
+                        response = requests.get(url, stream=True)
+                        print(f"HTTP response status: {response.status_code}")  # Debugging
+                        response.raise_for_status()
+
+                        # Save the file locally
+                        local_file_path = os.path.join(local_dir, os.path.basename(file_name))
+                        with open(local_file_path, 'wb') as file:
+                            for chunk in response.iter_content(chunk_size=8192):
+                                file.write(chunk)
+                        print(f"Downloaded model file: {file_name} to {local_file_path}")
+                        break  # Exit the retry loop if successful
+                    except (requests.HTTPError, requests.Timeout) as e:
+                        print(f"Error downloading {file_name}: {e}. Retrying in {delay} seconds...")
+                        time.sleep(delay)
+                else:
+                    raise Exception(f"Failed to download {file_name} after multiple attempts.")
+
+            return local_dir  # Return the directory where models are saved
+
+        except (requests.HTTPError, requests.Timeout) as e:
+            print(f"Error downloading files: {e}. Retrying in {delay} seconds...")
+            attempt += 1
+            time.sleep(delay)
+
+    raise Exception("Failed to download model files after multiple attempts.")
+
+def download_models_v1(repo_id="einarolafsson/models", local_dir=None, retries=5, delay=5):
     """
     Downloads all model files from Hugging Face and stores them in the specified local directory.
 

{spacr-0.3.42 → spacr-0.3.43/spacr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.42
+Version: 0.3.43
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson