spacr 0.3.60__py3-none-any.whl → 0.3.62__py3-none-any.whl

spacr/app_annotate.py

@@ -4,14 +4,6 @@ from .gui import MainApp
 from .gui_elements import set_dark_style, spacrButton
 
 def convert_to_number(value):
-    
-    """
-    Converts a string value to an integer if possible, otherwise converts to a float.
-    Args:
-        value (str): The string representation of the number.
-    Returns:
-        int or float: The converted number.
-    """
     try:
         return int(value)
     except ValueError:

spacr/core.py

@@ -465,10 +465,8 @@ def generate_image_umap(settings={}):
     display(settings_df)
 
     db_paths = get_db_paths(settings['src'])
-    
     tables = settings['tables'] + ['png_list']
     all_df = pd.DataFrame()
-    #image_paths = []
 
     for i,db_path in enumerate(db_paths):
         df = _read_and_join_tables(db_path, table_names=tables)
@@ -476,7 +474,7 @@ def generate_image_umap(settings={}):
         all_df = pd.concat([all_df, df], axis=0)
         #image_paths.extend(image_paths_tmp)
 
-    all_df['cond'] = all_df['col'].apply(map_condition, neg=settings['neg'], pos=settings['pos'], mix=settings['mix'])
+    all_df['cond'] = all_df['column_name'].apply(map_condition, neg=settings['neg'], pos=settings['pos'], mix=settings['mix'])
 
     if settings['exclude_conditions']:
         if isinstance(settings['exclude_conditions'], str):
@@ -495,7 +493,10 @@ def generate_image_umap(settings={}):
         
         # Extract and reset the index for the column to compare
         col_to_compare = all_df[settings['col_to_compare']].reset_index(drop=True)
-
+        
+        #if settings['only_top_features']:
+        #    column_list = None
+            
         # Preprocess the data to obtain numeric data
         numeric_data = preprocess_data(all_df, settings['filter_by'], settings['remove_highly_correlated'], settings['log_data'], settings['exclude'])
 
@@ -571,7 +572,11 @@ def generate_image_umap(settings={}):
             print(f'Saved {reduction_method} embedding to {embedding_path} and grid to {grid_path}')
 
     # Add cluster labels to the dataframe
-    all_df['cluster'] = labels
+    if len(labels) > 0:
+        all_df['cluster'] = labels
+    else:
+        all_df['cluster'] = 1  # Assign a default cluster label
+        print("No clusters found. Consider reducing 'min_samples' or increasing 'eps' for DBSCAN.")
 
     # Save the results to a CSV file
     results_dir = os.path.join(settings['src'][0], 'results')
@@ -653,7 +658,7 @@ def reducer_hyperparameter_search(settings={}, reduction_params=None, dbscan_par
         df = _read_and_join_tables(db_path, table_names=tables)
         all_df = pd.concat([all_df, df], axis=0)
 
-    all_df['cond'] = all_df['col'].apply(map_condition, neg=settings['neg'], pos=settings['pos'], mix=settings['mix'])
+    all_df['cond'] = all_df['column_name'].apply(map_condition, neg=settings['neg'], pos=settings['pos'], mix=settings['mix'])
 
     if settings['exclude_conditions']:
         if isinstance(settings['exclude_conditions'], str):
@@ -882,7 +887,7 @@ def generate_screen_graphs(settings):
         db_loc = [os.path.join(src, 'measurements', 'measurements.db')]
         
         # Read and merge data from the database
-        df, _ = _read_and_merge_data(db_loc, settings['tables'], verbose=True, nuclei_limit=settings['nuclei_limit'], pathogen_limit=settings['pathogen_limit'], uninfected=settings['uninfected'])
+        df, _ = _read_and_merge_data(db_loc, settings['tables'], verbose=True, nuclei_limit=settings['nuclei_limit'], pathogen_limit=settings['pathogen_limit'])
         
         # Annotate the data
         df = annotate_conditions(df, cells=settings['cells'], cell_loc=None, pathogens=settings['controls'], pathogen_loc=settings['controls_loc'], treatments=None, treatment_loc=None)

spacr/gui_utils.py

@@ -225,14 +225,30 @@ def annotate(settings):
     conn.close()
 
     root = tk.Tk()
-    root.geometry(settings['geom'])
-    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'], normalize_channels=settings['normalize_channels'])
-    next_button = tk.Button(root, text="Next", command=app.next_page)
-    next_button.grid(row=app.grid_rows, column=app.grid_cols - 1)
-    back_button = tk.Button(root, text="Back", command=app.previous_page)
-    back_button.grid(row=app.grid_rows, column=app.grid_cols - 2)
-    exit_button = tk.Button(root, text="Exit", command=app.shutdown)
-    exit_button.grid(row=app.grid_rows, column=app.grid_cols - 3)
+    
+    root.geometry(f"{root.winfo_screenwidth()}x{root.winfo_screenheight()}")
+    
+    db_path = os.path.join(settings['src'], 'measurements/measurements.db')
+
+    app = AnnotateApp(root,
+                      db_path=db_path,
+                      src=settings['src'],
+                      image_type=settings['image_type'],
+                      channels=settings['channels'],
+                      image_size=settings['img_size'],
+                      annotation_column=settings['annotation_column'],
+                      normalize=settings['normalize'],
+                      percentiles=settings['percentiles'],
+                      measurement=settings['measurement'],
+                      threshold=settings['threshold'],
+                      normalize_channels=settings['normalize_channels'])
+    
+    #next_button = tk.Button(root, text="Next", command=app.next_page)
+    #next_button.grid(row=app.grid_rows, column=app.grid_cols - 1)
+    #back_button = tk.Button(root, text="Back", command=app.previous_page)
+    #back_button.grid(row=app.grid_rows, column=app.grid_cols - 2)
+    #exit_button = tk.Button(root, text="Exit", command=app.shutdown)
+    #exit_button.grid(row=app.grid_rows, column=app.grid_cols - 3)
     
     app.load_images()
     root.mainloop()

spacr/io.py

@@ -1777,7 +1777,7 @@ def _read_and_join_tables(db_path, table_names=['cell', 'cytoplasm', 'nucleus',
         png_list_df['cell_id'] = png_list_df['cell_id'].str[1:].astype(int)
         png_list_df.rename(columns={'cell_id': 'object_label'}, inplace=True)
         if 'cell' in dataframes:
-            join_cols = ['object_label', 'plate', 'row_name', 'column_name']
+            join_cols = ['object_label', 'plate', 'row_name', 'column_name','field']
             dataframes['cell'] = pd.merge(dataframes['cell'], png_list_df, on=join_cols, how='left')
         else:
             print("Cell table not found in database tables.")
@@ -2089,150 +2089,6 @@ def _read_db(db_loc, tables):
     conn.close()
     return dfs
     
-def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=False, pathogen_limit=False, uninfected=False):
-    """
-    Read and merge data from SQLite databases and perform data preprocessing.
-
-    Parameters:
-    - locs (list): A list of file paths to the SQLite database files.
-    - tables (list): A list of table names to read from the databases.
-    - verbose (bool): Whether to print verbose output. Default is False.
-    - nuclei_limit (bool): Whether to include multinucleated cells. Default is False.
-    - pathogen_limit (bool): Whether to include cells with multiple infections. Default is False.
-    - uninfected (bool): Whether to include non-infected cells. Default is False.
-
-    Returns:
-    - merged_df (pandas.DataFrame): The merged and preprocessed dataframe.
-    - obj_df_ls (list): A list of pandas DataFrames, each containing the data for a specific object type.
-    """
-
-    from .utils import _split_data
-    
-    #Extract plate DataFrames
-    all_dfs = []
-    for loc in locs:
-        db_dfs = _read_db(loc, tables)
-        all_dfs.append(db_dfs)
-    
-    #Extract Tables from DataFrames and concatinate rows
-    for i, dfs in enumerate(all_dfs):
-        if 'cell' in tables:
-            cell = dfs[0]
-            print(f'plate: {i+1} cells:{len(cell)}')
-
-        if 'nucleus' in tables:
-            nucleus = dfs[1]
-            print(f'plate: {i+1} nucleus:{len(nucleus)} ')
-
-        if 'pathogen' in tables:
-            pathogen = dfs[2]
-            
-            print(f'plate: {i+1} pathogens:{len(pathogen)}')
-        if 'cytoplasm' in tables:
-            if not 'pathogen' in tables:
-                cytoplasm = dfs[2]
-            else:
-                cytoplasm = dfs[3]
-            print(f'plate: {i+1} cytoplasms: {len(cytoplasm)}')
-
-        if i > 0:
-            if 'cell' in tables:
-                cells = pd.concat([cells, cell], axis = 0)
-            if 'nucleus' in tables:
-                nucleus = pd.concat([nucleus, nucleus], axis = 0)
-            if 'pathogen' in tables:
-                pathogens = pd.concat([pathogens, pathogen], axis = 0)
-            if 'cytoplasm' in tables:
-                cytoplasms = pd.concat([cytoplasms, cytoplasm], axis = 0)
-        else:
-            if 'cell' in tables:
-                cells = cell.copy()
-            if 'nucleus' in tables:
-                nucleus = nucleus.copy()
-            if 'pathogen' in tables:
-                pathogens = pathogen.copy()
-            if 'cytoplasm' in tables:
-                cytoplasms = cytoplasm.copy()
-    
-    #Add an o in front of all object and cell lables to convert them to strings
-    if 'cell' in tables:
-        cells = cells.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
-        cells = cells.assign(prcfo = lambda x: x['prcf'] + '_' + x['object_label'])
-        cells_g_df, metadata = _split_data(cells, 'prcfo', 'object_label')
-        print(f'cells: {len(cells)}')
-        print(f'cells grouped: {len(cells_g_df)}')
-    if 'cytoplasm' in tables:
-        cytoplasms = cytoplasms.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
-        cytoplasms = cytoplasms.assign(prcfo = lambda x: x['prcf'] + '_' + x['object_label'])
-        cytoplasms_g_df, _ = _split_data(cytoplasms, 'prcfo', 'object_label')
-        merged_df = cells_g_df.merge(cytoplasms_g_df, left_index=True, right_index=True)
-        print(f'cytoplasms: {len(cytoplasms)}')
-        print(f'cytoplasms grouped: {len(cytoplasms_g_df)}')
-    if 'nucleus' in tables:
-        nucleus = nucleus.dropna(subset=['cell_id'])
-        nucleus = nucleus.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
-        nucleus = nucleus.assign(cell_id=lambda x: 'o' + x['cell_id'].astype(int).astype(str))
-        nucleus = nucleus.assign(prcfo = lambda x: x['prcf'] + '_' + x['cell_id'])
-        nucleus['nucleus_prcfo_count'] = nucleus.groupby('prcfo')['prcfo'].transform('count')
-        if nuclei_limit == False:
-            #nucleus = nucleus[~nucleus['prcfo'].duplicated()]
-            nucleus = nucleus[nucleus['nucleus_prcfo_count']==1]
-        nucleus_g_df, _ = _split_data(nucleus, 'prcfo', 'cell_id')
-        print(f'nucleus: {len(nucleus)}')
-        print(f'nucleus grouped: {len(nucleus_g_df)}')
-        if 'cytoplasm' in tables:
-            merged_df = merged_df.merge(nucleus_g_df, left_index=True, right_index=True)
-        else:
-            merged_df = cells_g_df.merge(nucleus_g_df, left_index=True, right_index=True)
-    if 'pathogen' in tables:
-        pathogens = pathogens.dropna(subset=['cell_id'])
-        pathogens = pathogens.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
-        pathogens = pathogens.assign(cell_id=lambda x: 'o' + x['cell_id'].astype(int).astype(str))
-        pathogens = pathogens.assign(prcfo = lambda x: x['prcf'] + '_' + x['cell_id'])
-        pathogens['pathogen_prcfo_count'] = pathogens.groupby('prcfo')['prcfo'].transform('count')
-        if uninfected == False:
-            pathogens = pathogens[pathogens['pathogen_prcfo_count']>=1]
-        if pathogen_limit == False:
-            pathogens = pathogens[pathogens['pathogen_prcfo_count']<=1]
-        pathogens_g_df, _ = _split_data(pathogens, 'prcfo', 'cell_id')
-        print(f'pathogens: {len(pathogens)}')
-        print(f'pathogens grouped: {len(pathogens_g_df)}')
-        merged_df = merged_df.merge(pathogens_g_df, left_index=True, right_index=True)
-    
-    #Add prc column (plate row column)
-    metadata = metadata.assign(prc = lambda x: x['plate'] + '_' + x['row_name'] + '_' +x['column_name'])
-
-    #Count cells per well
-    cells_well = pd.DataFrame(metadata.groupby('prc')['object_label'].nunique())
-
-    cells_well.reset_index(inplace=True)
-    cells_well.rename(columns={'object_label': 'cells_per_well'}, inplace=True)
-    metadata = pd.merge(metadata, cells_well, on='prc', how='inner', suffixes=('', '_drop_col'))
-    object_label_cols = [col for col in metadata.columns if '_drop_col' in col]
-    metadata.drop(columns=object_label_cols, inplace=True)
-
-    #Add prcfo column (plate row column field object)
-    metadata = metadata.assign(prcfo = lambda x: x['plate'] + '_' + x['row_name'] + '_' +x['column_name']+ '_' +x['field']+ '_' +x['object_label'])
-    metadata.set_index('prcfo', inplace=True)
-
-    merged_df = metadata.merge(merged_df, left_index=True, right_index=True)
-    
-    merged_df = merged_df.dropna(axis=1)
-    
-    print(f'Generated dataframe with: {len(merged_df.columns)} columns and {len(merged_df)} rows')
-    
-    obj_df_ls = []
-    if 'cell' in tables:
-        obj_df_ls.append(cells)
-    if 'cytoplasm' in tables:
-        obj_df_ls.append(cytoplasms)
-    if 'nucleus' in tables:
-        obj_df_ls.append(nucleus)
-    if 'pathogen' in tables:
-        obj_df_ls.append(pathogens)
-        
-    return merged_df, obj_df_ls
-    
 def _results_to_csv(src, df, df_well):
     """
     Save the given dataframes as CSV files in the specified directory.
@@ -2420,7 +2276,7 @@ def _read_db(db_loc, tables):
     conn.close() # Close the connection
     return dfs
     
-def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=False, pathogen_limit=False, uninfected=False):
+def _read_and_merge_data_v1(locs, tables, verbose=False, nuclei_limit=False, pathogen_limit=False):
     
     from .utils import _split_data
     
@@ -2532,11 +2388,6 @@ def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=False, pathog
         pathogens = pathogens.assign(prcfo = lambda x: x['prcf'] + '_' + x['cell_id'])
         pathogens['pathogen_prcfo_count'] = pathogens.groupby('prcfo')['prcfo'].transform('count')
         
-        print(f"before noninfected: {len(pathogens)}")
-        if uninfected == False:
-            pathogens = pathogens[pathogens['pathogen_prcfo_count']>=1]
-            print(f"after noninfected: {len(pathogens)}")
-
         if isinstance(pathogen_limit, bool):
             if pathogen_limit == False:
                 pathogens = pathogens[pathogens['pathogen_prcfo_count']<=1]
@@ -2592,7 +2443,135 @@ def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=False, pathog
     if 'pathogen' in tables:
         obj_df_ls.append(pathogens)
         
-    return merged_df, obj_df_ls  
+    return merged_df, obj_df_ls 
+
+def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=10, pathogen_limit=10):
+    from .io import _read_db
+    from .utils import _split_data
+
+    # Initialize an empty dictionary to store DataFrames by table name
+    data_dict = {table: [] for table in tables}
+
+    # Extract plate DataFrames
+    for loc in locs:
+        db_dfs = _read_db(loc, tables)
+        for table, df in zip(tables, db_dfs):
+            data_dict[table].append(df)
+
+    # Concatenate rows across locations for each table
+    for table, dfs in data_dict.items():
+        if dfs:
+            data_dict[table] = pd.concat(dfs, axis=0)
+        if verbose:
+            print(f"{table}: {len(data_dict[table])}")
+
+    # Initialize merged DataFrame with 'cells' if available
+    merged_df = pd.DataFrame()
+
+    # Process each table
+    if 'cell' in data_dict:
+        cells = data_dict['cell'].copy()
+        cells = cells.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
+        cells = cells.assign(prcfo=lambda x: x['prcf'] + '_' + x['object_label'])
+        cells_g_df, metadata = _split_data(cells, 'prcfo', 'object_label')
+        merged_df = cells_g_df.copy()
+        if verbose:
+            print(f'cells: {len(cells)}, cells grouped: {len(cells_g_df)}')
+
+    if 'cytoplasm' in data_dict:
+        cytoplasms = data_dict['cytoplasm'].copy()
+        cytoplasms = cytoplasms.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
+        cytoplasms = cytoplasms.assign(prcfo=lambda x: x['prcf'] + '_' + x['object_label'])
+        
+        if not 'cell' in data_dict:
+            merged_df, metadata = _split_data(cytoplasms, 'prcfo', 'object_label')
+            
+            if verbose:
+                print(f'nucleus: {len(cytoplasms)}, cytoplasms grouped: {len(merged_df)}')
+            
+        else:
+            cytoplasms_g_df, _ = _split_data(cytoplasms, 'prcfo', 'object_label')
+            merged_df = merged_df.merge(cytoplasms_g_df, left_index=True, right_index=True)
+            
+            if verbose:
+                print(f'cytoplasms: {len(cytoplasms)}, cytoplasms grouped: {len(cytoplasms_g_df)}')
+
+    if 'nucleus' in data_dict:
+        nucleus = data_dict['nucleus'].copy()
+        nucleus = nucleus.dropna(subset=['cell_id'])
+        nucleus = nucleus.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
+        nucleus = nucleus.assign(cell_id=lambda x: 'o' + x['cell_id'].astype(int).astype(str))
+        nucleus = nucleus.assign(prcfo=lambda x: x['prcf'] + '_' + x['cell_id'])
+        nucleus['nucleus_prcfo_count'] = nucleus.groupby('prcfo')['prcfo'].transform('count')
+        if not nuclei_limit:
+            nucleus = nucleus[nucleus['nucleus_prcfo_count'] == 1]
+            
+        if all(key not in data_dict for key in ['cell', 'cytoplasm']):
+            merged_df, metadata = _split_data(nucleus, 'prcfo', 'cell_id')
+            
+            if verbose:
+                print(f'nucleus: {len(nucleus)}, nucleus grouped: {len(merged_df)}')
+            
+        else:
+            nucleus_g_df, _ = _split_data(nucleus, 'prcfo', 'cell_id')
+            merged_df = merged_df.merge(nucleus_g_df, left_index=True, right_index=True)
+            
+            if verbose:
+                print(f'nucleus: {len(nucleus)}, nucleus grouped: {len(nucleus_g_df)}')
+
+    if 'pathogen' in data_dict:
+        pathogens = data_dict['pathogen'].copy()
+        pathogens = pathogens.dropna(subset=['cell_id'])
+        pathogens = pathogens.assign(object_label=lambda x: 'o' + x['object_label'].astype(int).astype(str))
+        pathogens = pathogens.assign(cell_id=lambda x: 'o' + x['cell_id'].astype(int).astype(str))
+        pathogens = pathogens.assign(prcfo=lambda x: x['prcf'] + '_' + x['cell_id'])
+        pathogens['pathogen_prcfo_count'] = pathogens.groupby('prcfo')['prcfo'].transform('count')
+
+        if isinstance(pathogen_limit, bool) and not pathogen_limit:
+            pathogens = pathogens[pathogens['pathogen_prcfo_count'] <= 1]
+        elif isinstance(pathogen_limit, (float, int)):
+            pathogens = pathogens[pathogens['pathogen_prcfo_count'] <= int(pathogen_limit)]
+
+        if all(key not in data_dict for key in ['cell', 'cytoplasm', 'nucleus']):
+            merged_df, metadata = _split_data(pathogens, 'prcfo', 'cell_id')
+            
+            if verbose:
+                print(f'pathogens: {len(pathogens)}, pathogens grouped: {len(merged_df)}')
+            
+        else:
+            pathogens_g_df, _ = _split_data(pathogens, 'prcfo', 'cell_id')
+            merged_df = merged_df.merge(pathogens_g_df, left_index=True, right_index=True)
+        
+            if verbose:
+                print(f'pathogens: {len(pathogens)}, pathogens grouped: {len(pathogens_g_df)}')
+            
+    if 'png_list' in data_dict:
+        png_list = data_dict['png_list'].copy()
+        png_list_g_df_numeric, png_list_g_df_non_numeric = _split_data(png_list, 'prcfo', 'cell_id')
+        png_list_g_df_non_numeric.drop(columns=['plate','row_name','column_name','field','file_name','cell_id', 'prcf'], inplace=True)
+        if verbose:
+            print(f'png_list: {len(png_list)}, png_list grouped: {len(png_list_g_df_numeric)}')
+        merged_df = merged_df.merge(png_list_g_df_numeric, left_index=True, right_index=True)
+        merged_df = merged_df.merge(png_list_g_df_non_numeric, left_index=True, right_index=True)
+        
+    # Add prc (plate row column) and prcfo (plate row column field object) columns
+    metadata = metadata.assign(prc=lambda x: x['plate'] + '_' + x['row_name'] + '_' + x['column_name'])
+    cells_well = metadata.groupby('prc')['object_label'].nunique().reset_index(name='cells_per_well')
+    metadata = metadata.merge(cells_well, on='prc')
+    metadata = metadata.assign(prcfo=lambda x: x['plate'] + '_' + x['row_name'] + '_' + x['column_name'] + '_' + x['field'] + '_' + x['object_label'])
+    metadata.set_index('prcfo', inplace=True)
+    
+    # Merge metadata with final merged DataFrame
+    merged_df = metadata.merge(merged_df, left_index=True, right_index=True).dropna(axis=1)
+    merged_df.drop(columns=['label_list_morphology', 'label_list_intensity'], errors='ignore', inplace=True)
+    
+    if verbose:
+        print(f'Generated dataframe with: {len(merged_df.columns)} columns and {len(merged_df)} rows')
+    
+    # Prepare object DataFrames for output
+    obj_df_ls = [data_dict[table] for table in ['cell', 'cytoplasm', 'nucleus', 'pathogen'] if table in data_dict]
+    
+    return merged_df, obj_df_ls
     
 def _read_mask(mask_path):
     mask = imageio2.imread(mask_path)
@@ -2929,8 +2908,8 @@ def generate_training_dataset(settings):
                                      tables=tables,
                                      verbose=False,
                                      nuclei_limit=settings['nuclei_limit'],
-                                     pathogen_limit=settings['pathogen_limit'],
-                                     uninfected=settings['uninfected'])
+                                     pathogen_limit=settings['pathogen_limit'])
+                
         [png_list_df] = _read_db(db_loc=db_path, tables=['png_list'])
         filtered_png_list_df = png_list_df[png_list_df['prcfo'].isin(df.index)]
         return filtered_png_list_df
@@ -2952,8 +2931,7 @@ def generate_training_dataset(settings):
                                      tables=tables,
                                      verbose=False,
                                      nuclei_limit=settings['nuclei_limit'],
-                                     pathogen_limit=settings['pathogen_limit'],
-                                     uninfected=settings['uninfected'])
+                                     pathogen_limit=settings['pathogen_limit'])
 
         print('length df 1', len(df))
         df = annotate_conditions(df, cells=['HeLa'], pathogens=['pathogen'], treatments=settings['classes'],
@@ -3034,7 +3012,6 @@ def generate_training_dataset(settings):
         
     if 'pathogen' not in settings['tables']:
         settings['pathogen_limit'] = 0
-        settings['uninfected'] = True
        
     # Set default settings and save
     settings = set_generate_training_dataset_defaults(settings)

spacr/ml.py

@@ -1172,15 +1172,14 @@ def generate_ml_scores(settings):
     db_loc = [src+'/measurements/measurements.db']
     tables = ['cell', 'nucleus', 'pathogen','cytoplasm']
 
-    nuclei_limit, pathogen_limit, uninfected = settings['nuclei_limit'], settings['pathogen_limit'], settings['uninfected']
+    nuclei_limit, pathogen_limit = settings['nuclei_limit'], settings['pathogen_limit']
     
     df, _ = _read_and_merge_data(db_loc, 
                                  tables,
                                  settings['verbose'],
                                  nuclei_limit,
-                                 pathogen_limit,
-                                 uninfected)
-
+                                 pathogen_limit)
+    
     if settings['annotation_column'] is not None:
 
         settings['location_column'] = settings['annotation_column']