spacr 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

spacr/utils.py

@@ -1,6 +1,7 @@
-import sys, os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform, gzip, subprocess
+import os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform, gzip, subprocess, time, requests
 
 import numpy as np
+import pandas as pd
 from cellpose import models as cp_models
 from cellpose import denoise
 
@@ -14,7 +15,6 @@ from skimage.segmentation import clear_border
 
 from collections import defaultdict, OrderedDict
 from PIL import Image
-import pandas as pd
 from statsmodels.stats.outliers_influence import variance_inflation_factor
 from statsmodels.stats.stattools import durbin_watson
 import statsmodels.formula.api as smf
@@ -24,7 +24,7 @@ from itertools import combinations
 from functools import reduce
 from IPython.display import display
 
-from multiprocessing import Pool, cpu_count
+from multiprocessing import Pool, cpu_count, set_start_method, get_start_method
 from concurrent.futures import ThreadPoolExecutor
 
 import torch.nn as nn
@@ -33,63 +33,44 @@ from torch.utils.checkpoint import checkpoint
 from torch.utils.data import Subset
 from torch.autograd import grad
 
+from torchvision import models
+from torchvision.models.resnet import ResNet18_Weights, ResNet34_Weights, ResNet50_Weights, ResNet101_Weights, ResNet152_Weights
+import torchvision.transforms as transforms
+from torchvision.models import resnet50
+
 import seaborn as sns
 import matplotlib.pyplot as plt
 from matplotlib.offsetbox import OffsetImage, AnnotationBbox
 
+from scipy import stats
 import scipy.ndimage as ndi
 from scipy.spatial import distance
-from scipy.stats import fisher_exact
+from scipy.stats import fisher_exact, f_oneway, kruskal
 from scipy.ndimage.filters import gaussian_filter
 from scipy.spatial import ConvexHull
 from scipy.interpolate import splprep, splev
 from scipy.ndimage import binary_dilation
 
-from sklearn.preprocessing import StandardScaler
 from skimage.exposure import rescale_intensity
 from sklearn.metrics import auc, precision_recall_curve
 from sklearn.model_selection import train_test_split
 from sklearn.linear_model import Lasso, Ridge
-from sklearn.preprocessing import OneHotEncoder
-from sklearn.cluster import KMeans
-from sklearn.preprocessing import StandardScaler
-from sklearn.cluster import DBSCAN
-from sklearn.cluster import KMeans
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from sklearn.cluster import KMeans, DBSCAN
 from sklearn.manifold import TSNE
-from sklearn.cluster import KMeans
 from sklearn.decomposition import PCA
-
-import umap.umap_ as umap
-
-from torchvision import models
-from torchvision.models.resnet import ResNet18_Weights, ResNet34_Weights, ResNet50_Weights, ResNet101_Weights, ResNet152_Weights
-import torchvision.transforms as transforms
-
 from sklearn.ensemble import RandomForestClassifier
-from sklearn.preprocessing import StandardScaler
-from scipy.stats import f_oneway, kruskal
-from sklearn.cluster import KMeans
-from scipy import stats
 
-from .logger import log_function_call
-from multiprocessing import set_start_method, get_start_method
+from huggingface_hub import list_repo_files
 
-import torch
-import torchvision.transforms as transforms
-from torchvision.models import resnet50
-from PIL import Image
-import numpy as np
-import umap
-import pandas as pd
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.preprocessing import StandardScaler
-from scipy.stats import f_oneway, kruskal
-from sklearn.cluster import KMeans
-from scipy import stats
+import umap.umap_ as umap
+#import umap
 
-def save_settings(settings, name='settings'):
+def save_settings(settings, name='settings', show=False):
     
     settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
+    if show:
+        display(settings_df)
     settings_csv = os.path.join(settings['src'],'settings',f'{name}.csv')
     os.makedirs(os.path.join(settings['src'],'settings'), exist_ok=True)
     settings_df.to_csv(settings_csv, index=False)
@@ -303,7 +284,10 @@ def _get_cellpose_batch_size():
     except Exception as e:
         return 8
 
-def _extract_filename_metadata(filenames, src, images_by_key, regular_expression, metadata_type='cellvoyager', pick_slice=False, skip_mode='01'):
+def _extract_filename_metadata_v1(filenames, src, regular_expression, metadata_type='cellvoyager', pick_slice=False, skip_mode='01'):
+    
+    images_by_key = defaultdict(list)
+    
     for filename in filenames:
         match = regular_expression.match(filename)
         if match:
@@ -328,7 +312,6 @@ def _extract_filename_metadata(filenames, src, images_by_key, regular_expression
                 if metadata_type =='cq1':
                     orig_wellID = wellID
                     wellID = _convert_cq1_well_id(wellID)
-                    #clear_output(wait=True)
                     print(f'Converted Well ID: {orig_wellID} to {wellID}', end='\r', flush=True)
 
                 if pick_slice:
@@ -338,7 +321,7 @@ def _extract_filename_metadata(filenames, src, images_by_key, regular_expression
                         sliceid = '00'
 
                     if mode == skip_mode:
-                        continue      
+                        continue
                         
                 key = (plate, well, field, channel, mode)
                 with Image.open(os.path.join(src, filename)) as img:
@@ -351,6 +334,57 @@ def _extract_filename_metadata(filenames, src, images_by_key, regular_expression
         
     return images_by_key
 
+def _extract_filename_metadata(filenames, src, regular_expression, metadata_type='cellvoyager', pick_slice=False, skip_mode='01'):
+    
+    images_by_key = defaultdict(list)
+    
+    for filename in filenames:
+        match = regular_expression.match(filename)
+        if match:
+            try:
+                try:
+                    plate = match.group('plateID')
+                except:
+                    plate = os.path.basename(src)
+
+                well = match.group('wellID')
+                field = match.group('fieldID')
+                channel = match.group('chanID')
+                mode = None
+
+                if well[0].isdigit():
+                    well = str(_safe_int_convert(well))
+                if field[0].isdigit():
+                    field = str(_safe_int_convert(field))
+                if channel[0].isdigit():
+                    channel = str(_safe_int_convert(channel))
+
+                if metadata_type =='cq1':
+                    orig_wellID = wellID
+                    wellID = _convert_cq1_well_id(wellID)
+                    print(f'Converted Well ID: {orig_wellID} to {wellID}', end='\r', flush=True)
+
+                if pick_slice:
+                    try:
+                        mode = match.group('AID')
+                    except IndexError:
+                        sliceid = '00'
+
+                    if mode == skip_mode:
+                        continue
+                        
+                key = (plate, well, field, channel, mode)
+                file_path = os.path.join(src, filename)  # Store the full path
+                images_by_key[key].append(file_path)
+                
+            except IndexError:
+                print(f"Could not extract information from filename {filename} using provided regex")
+        else:
+            print(f"Filename {filename} did not match provided regex")
+            continue
+        
+    return images_by_key
+
 def mask_object_count(mask):
     """
     Counts the number of objects in a given mask.
@@ -441,7 +475,7 @@ def _generate_representative_images(db_path, cells=['HeLa'], cell_loc=None, path
     from .plot import _plot_images_on_grid
     
     df = _read_and_join_tables(db_path)
-    df = _annotate_conditions(df, cells, cell_loc, pathogens, pathogen_loc, treatments,treatment_loc)
+    df = annotate_conditions(df, cells, cell_loc, pathogens, pathogen_loc, treatments, treatment_loc)
     
     if update_db:
         _update_database_with_merged_info(db_path, df, table='png_list', columns=['pathogen', 'treatment', 'host_cells', 'condition', 'prcfo'])
@@ -487,34 +521,6 @@ def _map_values(row, values, locs):
         return value_dict.get(row[type_], None)
     return values[0] if values else None
 
-def _annotate_conditions(df, cells=['HeLa'], cell_loc=None, pathogens=['rh'], pathogen_loc=None, treatments=['cm'], treatment_loc=None):
-    """
-    Annotates conditions in the given DataFrame based on the provided parameters.
-
-    Args:
-        df (pandas.DataFrame): The DataFrame to annotate.
-        cells (list, optional): The list of host cell types. Defaults to ['HeLa'].
-        cell_loc (list, optional): The list of location identifiers for host cells. Defaults to None.
-        pathogens (list, optional): The list of pathogens. Defaults to ['rh'].
-        pathogen_loc (list, optional): The list of location identifiers for pathogens. Defaults to None.
-        treatments (list, optional): The list of treatments. Defaults to ['cm'].
-        treatment_loc (list, optional): The list of location identifiers for treatments. Defaults to None.
-
-    Returns:
-        pandas.DataFrame: The annotated DataFrame with the 'host_cells', 'pathogen', 'treatment', and 'condition' columns.
-    """
-
-
-    # Apply mappings or defaults
-    df['host_cells'] = [cells[0]] * len(df) if cell_loc is None else df.apply(_map_values, args=(cells, cell_loc), axis=1)
-    df['pathogen'] = [pathogens[0]] * len(df) if pathogen_loc is None else df.apply(_map_values, args=(pathogens, pathogen_loc), axis=1)
-    df['treatment'] = [treatments[0]] * len(df) if treatment_loc is None else df.apply(_map_values, args=(treatments, treatment_loc), axis=1)
-
-    # Construct condition column
-    df['condition'] = df.apply(lambda row: '_'.join(filter(None, [row.get('pathogen'), row.get('treatment')])), axis=1)
-    df['condition'] = df['condition'].apply(lambda x: x if x else 'none')
-    return df
-
 def is_list_of_lists(var):
     if isinstance(var, list) and all(isinstance(i, list) for i in var):
         return True
@@ -1083,67 +1089,74 @@ def _get_cellpose_channels(src, nucleus_channel, pathogen_channel, cell_channel)
         else:
             cellpose_channels['cell'] = [0,0]
     return cellpose_channels
-    
-def annotate_conditions(df, cells=['HeLa'], cell_loc=None, pathogens=['rh'], pathogen_loc=None, treatments=['cm'], treatment_loc=None, types = ['col','col','col']):
+
+def annotate_conditions(df, cells=None, cell_loc=None, pathogens=None, pathogen_loc=None, treatments=None, treatment_loc=None):
     """
-    Annotates conditions in a DataFrame based on specified criteria.
+    Annotates conditions in a DataFrame based on specified criteria and combines them into a 'condition' column.
+    NaN is used for missing values, and they are excluded from the 'condition' column.
 
     Args:
         df (pandas.DataFrame): The DataFrame to annotate.
-        cells (list, optional): List of host cell types. Defaults to ['HeLa'].
-        cell_loc (list, optional): List of corresponding values for each host cell type. Defaults to None.
-        pathogens (list, optional): List of pathogens. Defaults to ['rh'].
-        pathogen_loc (list, optional): List of corresponding values for each pathogen. Defaults to None.
-        treatments (list, optional): List of treatments. Defaults to ['cm'].
-        treatment_loc (list, optional): List of corresponding values for each treatment. Defaults to None.
-        types (list, optional): List of column types for host cells, pathogens, and treatments. Defaults to ['col','col','col'].
+        cells (list/str, optional): Host cell types. Defaults to None.
+        cell_loc (list of lists, optional): Values for each host cell type. Defaults to None.
+        pathogens (list/str, optional): Pathogens. Defaults to None.
+        pathogen_loc (list of lists, optional): Values for each pathogen. Defaults to None.
+        treatments (list/str, optional): Treatments. Defaults to None.
+        treatment_loc (list of lists, optional): Values for each treatment. Defaults to None.
 
     Returns:
-        pandas.DataFrame: The annotated DataFrame.
+        pandas.DataFrame: Annotated DataFrame with a combined 'condition' column.
     """
+    
+    def _get_type(val):
+        """Determine if a value maps to 'row' or 'col'."""
+        if isinstance(val, str) and val.startswith('c'):
+            return 'col'
+        elif isinstance(val, str) and val.startswith('r'):
+            return 'row'
+        return None
 
-    # Function to apply to each row
-    def _map_values(row, dict_, type_='col'):
+    def _map_or_default(column_name, values, loc, df):
         """
-        Maps the values in a row to corresponding keys in a dictionary.
+        Consolidates the logic for mapping values or assigning defaults when loc is None.
 
         Args:
-            row (dict): The row containing the values to be mapped.
-            dict_ (dict): The dictionary containing the mapping values.
-            type_ (str, optional): The type of mapping to perform. Defaults to 'col'.
-
-        Returns:
-            str: The mapped value if found, otherwise None.
+            column_name (str): The column in the DataFrame to annotate.
+            values (list/str): The list of values or a single string to annotate.
+            loc (list of lists): Location mapping for the values, or None if not used.
+            df (pandas.DataFrame): The DataFrame to modify.
         """
-        for values, cols in dict_.items():
-            if row[type_] in cols:
-                return values
-        return None
+        if isinstance(values, str) or (isinstance(values, list) and loc is None):
+            # Assign all rows the first value in the list or the single string
+            df[column_name] = values if isinstance(values, str) else values[0]
+        elif values is not None and loc is not None:
+            # Perform the location-based mapping
+            value_dict = {val: key for key, loc_list in zip(values, loc) for val in loc_list}
+            df[column_name] = np.nan
+            for val, key in value_dict.items():
+                loc_type = _get_type(val)
+                if loc_type:
+                    df.loc[df[loc_type] == val, column_name] = key
+
+    # Handle cells, pathogens, and treatments using the consolidated logic
+    _map_or_default('host_cells', cells, cell_loc, df)
+    _map_or_default('pathogen', pathogens, pathogen_loc, df)
+    _map_or_default('treatment', treatments, treatment_loc, df)
+
+    # Conditionally fill NaN for pathogen and treatment columns if applicable
+    if pathogens is not None:
+        df['pathogen'].fillna(np.nan, inplace=True)
+    if treatments is not None:
+        df['treatment'].fillna(np.nan, inplace=True)
+
+    # Create the 'condition' column by excluding any NaN values, safely checking if 'host_cells', 'pathogen', and 'treatment' exist
+    df['condition'] = df.apply(
+        lambda x: '_'.join([str(v) for v in [x.get('host_cells'), x.get('pathogen'), x.get('treatment')] if pd.notna(v)]), 
+        axis=1
+    )
 
-    if cell_loc is None:
-        df['host_cells'] = cells[0]
-    else:
-        cells_dict = dict(zip(cells, cell_loc))
-        df['host_cells'] = df.apply(lambda row: _map_values(row, cells_dict, type_=types[0]), axis=1)
-    if pathogen_loc is None:
-        if pathogens != None:
-            df['pathogen'] = 'none'
-    else:
-        pathogens_dict = dict(zip(pathogens, pathogen_loc))
-        df['pathogen'] = df.apply(lambda row: _map_values(row, pathogens_dict, type_=types[1]), axis=1)
-    if treatment_loc is None:
-        df['treatment'] = 'cm'
-    else:
-        treatments_dict = dict(zip(treatments, treatment_loc))
-        df['treatment'] = df.apply(lambda row: _map_values(row, treatments_dict, type_=types[2]), axis=1)
-    if pathogens != None:
-        df['condition'] = df['pathogen']+'_'+df['treatment']
-    else:
-        df['condition'] = df['treatment']
     return df
-    
 
-    
 def _split_data(df, group_by, object_type):
     """
     Splits the input dataframe into numeric and non-numeric parts, groups them by the specified column,
@@ -1949,9 +1962,10 @@ def add_images_to_tar(paths_chunk, tar_path, total_images):
                 tar.add(img_path, arcname=arcname)
                 with lock:
                     counter.value += 1
-                    if counter.value % 100 == 0:  # Print every 100 updates
-                        progress = (counter.value / total_images) * 100
-                        print(f"Progress: {counter.value}/{total_images} ({progress:.2f}%)", end='\r', file=sys.stdout, flush=True)
+                    if counter.value % 10 == 0:  # Print every 100 updates
+                        #progress = (counter.value / total_images) * 100
+                        #print(f"Progress: {counter.value}/{total_images} ({progress:.2f}%)", end='\r', file=sys.stdout, flush=True)
+                        print_progress(counter.value, total_images, n_jobs=1, time_ls=None, batch_size=None, operation_type="generating .tar dataset")
             except FileNotFoundError:
                 print(f"File not found: {img_path}")
 
@@ -2068,52 +2082,6 @@ def check_multicollinearity(x):
     vif_data["VIF"] = [variance_inflation_factor(x.values, i) for i in range(x.shape[1])]
     return vif_data
 
-def generate_dependent_variable(df, dv_loc, pc_min=0.95, nc_max=0.05, agg_type='mean'):
-    
-    from .plot import _plot_histograms_and_stats, _plot_plates
-    
-    def qstring_to_float(qstr):
-        number = int(qstr[1:])  # Remove the "q" and convert the rest to an integer
-        return number / 100.0
-    
-    print("Unique values in plate:", df['plate'].unique())
-    dv_cell_loc = f'{dv_loc}/dv_cell.csv'
-    dv_well_loc = f'{dv_loc}/dv_well.csv'
-    
-    df['pred'] = 1-df['pred'] #if you swiched pc and nc
-    df = df[(df['pred'] <= nc_max) | (df['pred'] >= pc_min)]
-    
-    if 'prc' not in df.columns:
-        df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['col']
-    
-    if agg_type.startswith('q'):
-        val = qstring_to_float(agg_type)
-        agg_type = lambda x: x.quantile(val)
-    
-    # Aggregating for mean prediction and total count
-    df_grouped = df.groupby('prc').agg(
-        pred=('pred', agg_type),
-        recruitment=('recruitment', agg_type),
-        count_prc=('prc', 'size'),
-        #count_above_95=('pred', lambda x: (x > 0.95).sum()),
-        mean_pathogen_area=('pathogen_area', 'mean')
-    )
-    
-    df_cell = df[['prc', 'pred', 'pathogen_area', 'recruitment']]
-    
-    df_cell.to_csv(dv_cell_loc, index=True, header=True, mode='w')
-    df_grouped.to_csv(dv_well_loc, index=True, header=True, mode='w')  # Changed from loc to dv_loc
-    display(df)
-    _plot_histograms_and_stats(df)
-    df_grouped = df_grouped.sort_values(by='count_prc', ascending=True)
-    display(df_grouped)
-    print('pred')
-    _plot_plates(df=df_cell, variable='pred', grouping='mean', min_max='allq', cmap='viridis')
-    print('recruitment')
-    _plot_plates(df=df_cell, variable='recruitment', grouping='mean', min_max='allq', cmap='viridis')
-    
-    return df_grouped
-
 def lasso_reg(merged_df, alpha_value=0.01, reg_type='lasso'):
     # Separate predictors and response
     X = merged_df[['gene', 'grna', 'plate', 'row', 'column']]
@@ -3592,13 +3560,48 @@ def plot_grid(cluster_images, colors, figuresize, black_background, verbose):
     plt.show()
     return grid_fig
 
-def correct_paths(df, base_path):
+def generate_path_list_from_db(db_path, file_metadata):
+
+    all_paths = []
+
+    # Connect to the database and retrieve the image paths
+    print(f"Reading DataBase: {db_path}")
+    try:
+        with sqlite3.connect(db_path) as conn:
+            cursor = conn.cursor()
+            if file_metadata:
+                if isinstance(file_metadata, str):
+                    cursor.execute("SELECT png_path FROM png_list WHERE png_path LIKE ?", (f"%{file_metadata}%",))
+            else:
+                cursor.execute("SELECT png_path FROM png_list")
 
-    if 'png_path' not in df.columns:
-        print("No 'png_path' column found in the dataframe.")
-        return df, None
+            while True:
+                rows = cursor.fetchmany(1000)
+                if not rows:
+                    break
+                all_paths.extend([row[0] for row in rows])
+
+    except sqlite3.Error as e:
+        print(f"Database error: {e}")
+        return
+    except Exception as e:
+        print(f"Error: {e}")
+        return
     
-    image_paths = df['png_path'].to_list()
+    return all_paths
+
+def correct_paths(df, base_path):
+
+    if isinstance(df, pd.DataFrame):
+
+        if 'png_path' not in df.columns:
+            print("No 'png_path' column found in the dataframe.")
+            return df, None
+        else:
+            image_paths = df['png_path'].to_list()
+
+    elif isinstance(df, list):
+        image_paths = df
     
     adjusted_image_paths = []
     for path in image_paths:
@@ -3612,9 +3615,11 @@ def correct_paths(df, base_path):
         else:
             adjusted_image_paths.append(path)
 
-    df['png_path'] = adjusted_image_paths
-    image_paths = df['png_path'].to_list()
-    return df, image_paths
+    if isinstance(df, pd.DataFrame):
+        df['png_path'] = adjusted_image_paths
+        return df, adjusted_image_paths
+    else:
+        return adjusted_image_paths
 
 def delete_folder(folder_path):
     if os.path.exists(folder_path) and os.path.isdir(folder_path):
@@ -4422,7 +4427,7 @@ def convert_and_relabel_masks(folder_path):
 
 def correct_masks(src):
 
-    from .utils import _load_and_concatenate_arrays
+    from .io import _load_and_concatenate_arrays
 
     cell_path = os.path.join(src,'norm_channel_stack', 'cell_mask_stack')
     convert_and_relabel_masks(cell_path)
@@ -4445,4 +4450,101 @@ def get_cuda_version():
     except (subprocess.CalledProcessError, FileNotFoundError):
         return None
 
+def all_elements_match(list1, list2):
+    # Check if all elements in list1 are in list2
+    return all(element in list2 for element in list1)
+
+def prepare_batch_for_segmentation(batch):
+    # Ensure the batch is of dtype float32
+    if batch.dtype != np.float32:
+        batch = batch.astype(np.float32)
+    
+    # Normalize each image in the batch
+    for i in range(batch.shape[0]):
+        if batch[i].max() > 1:
+            batch[i] = batch[i] / batch[i].max()
+    
+    return batch
+
+def check_index(df, elements=5, split_char='_'):
+    problematic_indices = []
+    for idx in df.index:
+        parts = str(idx).split(split_char)
+        if len(parts) != elements:
+            problematic_indices.append(idx)
+    if problematic_indices:
+        print("Indices that cannot be separated into 5 parts:")
+        for idx in problematic_indices:
+            print(idx)
+        raise ValueError(f"Found {len(problematic_indices)} problematic indices that do not split into {elements} parts.")
+    
+# Define the mapping function
+def map_condition(col_value, neg='c1', pos='c2', mix='c3'):
+    if col_value == neg:
+        return 'neg'
+    elif col_value == pos:
+        return 'pos'
+    elif col_value == mix:
+        return 'mix'
+    else:
+        return 'screen'
+    
+def download_models(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.
+
+    Args:
+        repo_id (str): The repository ID on Hugging Face (default is 'einarolafsson/models').
+        local_dir (str): The local directory where models will be saved. Defaults to '/home/carruthers/Desktop/test'.
+        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.
+    """
+    # 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.")

{spacr-0.3.0.dist-info → spacr-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.0
+Version: 0.3.2
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -8,6 +8,7 @@ Author-email: olafsson@med.umich.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: torch<3.0,>=2.0
 Requires-Dist: torchvision<1.0,>=0.1
@@ -58,6 +59,10 @@ Requires-Dist: segmentation-models-pytorch>=0.3.3
 Requires-Dist: tifffile>=2023.4.12
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: wandb>=0.16.2
+Requires-Dist: openai<2.0,>=1.50.2
+Requires-Dist: nd2reader<4.0,>=3.3.0
+Requires-Dist: czifile
+Requires-Dist: adjustText<2.0,>=1.2.0
 Requires-Dist: huggingface-hub<0.25,>=0.24.0
 Provides-Extra: dev
 Requires-Dist: pytest<3.11,>=3.9; extra == "dev"
@@ -115,6 +120,7 @@ If using Windows, switch to Linux—it's free, open-source, and better.
 Before installing SpaCr on OSX ensure OpenMP is installed::
 
    brew install libomp
+   brew install hdf5
 
 SpaCr GUI requires Tkinter. On Linux, ensure Tkinter is installed. (Tkinter is included with the standard Python installation on macOS and Windows)::