spacr 0.0.70__py3-none-any.whl → 0.0.71__py3-none-any.whl

spacr/annotate_app.py

@@ -126,12 +126,10 @@ class ImageApp:
         Normalize the pixel values of an image to the range [0, 255].
 
         Parameters:
-        - img: PIL.Image.Image
-            The input image to be normalized.
+        - img: PIL.Image.Image. The input image to be normalized.
 
         Returns:
-        - PIL.Image.Image
-            The normalized image.
+        - PIL.Image.Image. The normalized image.
         """
         img_array = np.array(img)
         img_array = ((img_array - img_array.min()) * (1/(img_array.max() - img_array.min()) * 255)).astype('uint8')

spacr/core.py

@@ -3118,29 +3118,29 @@ def generate_image_umap(settings={}):
     
     Parameters:
     settings (dict): Dictionary containing the following keys:
-        src (str): Source directory containing the data.
-        row_limit (int): Limit the number of rows to process.
-        tables (list): List of table names to read from the database.
-        visualize (str): Visualization type.
-        image_nr (int): Number of images to display.
-        dot_size (int): Size of dots in the scatter plot.
-        n_neighbors (int): Number of neighbors for UMAP.
-        figuresize (int): Size of the figure.
-        black_background (bool): Whether to use a black background.
-        remove_image_canvas (bool): Whether to remove the image canvas.
-        plot_outlines (bool): Whether to plot outlines.
-        plot_points (bool): Whether to plot points.
-        smooth_lines (bool): Whether to smooth lines.
-        verbose (bool): Whether to print verbose output.
-        embedding_by_controls (bool): Whether to use embedding from controls.
-        col_to_compare (str): Column to compare for control-based embedding.
-        pos (str): Positive control value.
-        neg (str): Negative control value.
-        clustering (str): Clustering method ('DBSCAN' or 'KMeans').
-        exclude (list): List of columns to exclude from the analysis.
-        plot_images (bool): Whether to plot images.
-        reduction_method (str): Dimensionality reduction method ('UMAP' or 'tSNE').
-        save_figure (bool): Whether to save the figure as a PDF.
+    src (str): Source directory containing the data.
+    row_limit (int): Limit the number of rows to process.
+    tables (list): List of table names to read from the database.
+    visualize (str): Visualization type.
+    image_nr (int): Number of images to display.
+    dot_size (int): Size of dots in the scatter plot.
+    n_neighbors (int): Number of neighbors for UMAP.
+    figuresize (int): Size of the figure.
+    black_background (bool): Whether to use a black background.
+    remove_image_canvas (bool): Whether to remove the image canvas.
+    plot_outlines (bool): Whether to plot outlines.
+    plot_points (bool): Whether to plot points.
+    smooth_lines (bool): Whether to smooth lines.
+    verbose (bool): Whether to print verbose output.
+    embedding_by_controls (bool): Whether to use embedding from controls.
+    col_to_compare (str): Column to compare for control-based embedding.
+    pos (str): Positive control value.
+    neg (str): Negative control value.
+    clustering (str): Clustering method ('DBSCAN' or 'KMeans').
+    exclude (list): List of columns to exclude from the analysis.
+    plot_images (bool): Whether to plot images.
+    reduction_method (str): Dimensionality reduction method ('UMAP' or 'tSNE').
+    save_figure (bool): Whether to save the figure as a PDF.
     
     Returns:
     pd.DataFrame: DataFrame with the original data and an additional column 'cluster' containing the cluster identity.
@@ -3311,15 +3311,15 @@ def reducer_hyperparameter_search(settings={}, reduction_params=None, dbscan_par
     
     Parameters:
     settings (dict): Dictionary containing the following keys:
-        src (str): Source directory containing the data.
-        row_limit (int): Limit the number of rows to process.
-        tables (list): List of table names to read from the database.
-        filter_by (str): Column to filter the data.
-        sample_size (int): Number of samples to use for the hyperparameter search.
-        remove_highly_correlated (bool): Whether to remove highly correlated columns.
-        log_data (bool): Whether to log transform the data.
-        verbose (bool): Whether to print verbose output.
-        reduction_method (str): Dimensionality reduction method ('UMAP' or 'tSNE').
+    src (str): Source directory containing the data.
+    row_limit (int): Limit the number of rows to process.
+    tables (list): List of table names to read from the database.
+    filter_by (str): Column to filter the data.
+    sample_size (int): Number of samples to use for the hyperparameter search.
+    remove_highly_correlated (bool): Whether to remove highly correlated columns.
+    log_data (bool): Whether to log transform the data.
+    verbose (bool): Whether to print verbose output.
+    reduction_method (str): Dimensionality reduction method ('UMAP' or 'tSNE').
     reduction_params (list): List of dictionaries containing hyperparameters to test for the reduction method.
     dbscan_params (list): List of dictionaries containing DBSCAN hyperparameters to test.
     kmeans_params (list): List of dictionaries containing KMeans hyperparameters to test.

spacr/foldseek.py

@@ -762,18 +762,18 @@ def analyze_results(foldseek_csv_path, base_dir):
     #display(functional_data_df)
 
 # Set up directories
-structure_fldr_path = "/home/carruthers/Downloads/ME49_proteome/cif"
-base_dir='/home/carruthers/foldseek/me49'
+#structure_fldr_path = "/home/carruthers/Downloads/ME49_proteome/cif"
+#base_dir='/home/carruthers/foldseek/me49'
 
-align_to_database(structure_fldr_path, base_dir, cores=25)
+#align_to_database(structure_fldr_path, base_dir, cores=25)
 #foldseek_csv_path = f'{base_dir}/results/pdb/aln_tmscore.csv'
 #analyze_results(foldseek_csv_path, base_dir)
 
 # Set up directories
-structure_fldr_path = "/home/carruthers/Downloads/GT1_proteome/cif"
-base_dir='/home/carruthers/foldseek/gt1'
+#structure_fldr_path = "/home/carruthers/Downloads/GT1_proteome/cif"
+#base_dir='/home/carruthers/foldseek/gt1'
 
-align_to_database(structure_fldr_path, base_dir, cores=25)
+#align_to_database(structure_fldr_path, base_dir, cores=25)
 #foldseek_csv_path = f'{base_dir}/results/pdb/aln_tmscore.csv'
 #analyze_results(foldseek_csv_path, base_dir)
 

spacr/get_alfafold_structures.py

@@ -67,6 +67,6 @@ def download_alphafold_structures(tsv_location, dst, version="4"):
         print(f"Failed download entries saved to: {os.path.join(dst, 'failed_downloads.csv')}")
 
 # Example usage:
-tsv_location = '/home/carruthers/Downloads/GT1_proteome/GT1_proteins_uniprot.tsv'  # Replace with the path to your TSV file containing a list of UniProt entries
-dst_folder = '/home/carruthers/Downloads/GT1_proteome'  # Replace with your destination folder
-download_alphafold_structures(tsv_location, dst_folder)
+#tsv_location = '/home/carruthers/Downloads/GT1_proteome/GT1_proteins_uniprot.tsv'  # Replace with the path to your TSV file containing a list of UniProt entries
+#dst_folder = '/home/carruthers/Downloads/GT1_proteome'  # Replace with your destination folder
+#download_alphafold_structures(tsv_location, dst_folder)

spacr/io.py

@@ -255,31 +255,24 @@ class CombinedDataset(Dataset):
     
 class NoClassDataset(Dataset):
     """
-    A custom dataset class for handling images without class labels.
-
+    A custom dataset class for handling image data without class labels.
+    
     Args:
-        data_dir (str): The directory path where the images are stored.
-        transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed version. Default is None.
+        data_dir (str): The directory path where the image files are located.
+        transform (callable, optional): A function/transform to apply to the image data. Default is None.
         shuffle (bool, optional): Whether to shuffle the dataset. Default is True.
         load_to_memory (bool, optional): Whether to load all images into memory. Default is False.
-
+    
     Attributes:
-        data_dir (str): The directory path where the images are stored.
-        transform (callable): A function/transform that takes in an PIL image and returns a transformed version.
+        data_dir (str): The directory path where the image files are located.
+        transform (callable): A function/transform to apply to the image data.
         shuffle (bool): Whether to shuffle the dataset.
         load_to_memory (bool): Whether to load all images into memory.
-        filenames (list): List of file paths for the images.
-        images (list): List of loaded images (if load_to_memory is True).
-
-    Methods:
-        load_image: Loads an image from the given file path.
-        __len__: Returns the number of images in the dataset.
-        shuffle_dataset: Shuffles the dataset.
-        __getitem__: Retrieves an image and its corresponding file path from the dataset.
-
+        filenames (list): A list of file paths for the image files.
+        images (list): A list of loaded images (if load_to_memory is True).
     """
-
-    def _init__(self, data_dir, transform=None, shuffle=True, load_to_memory=False):
+    
+    def __init__(self, data_dir, transform=None, shuffle=True, load_to_memory=False):
         self.data_dir = data_dir
         self.transform = transform
         self.shuffle = shuffle
@@ -289,16 +282,47 @@ class NoClassDataset(Dataset):
             self.shuffle_dataset()
         if self.load_to_memory:
             self.images = [self.load_image(f) for f in self.filenames]
+    
     #@lru_cache(maxsize=None)
     def load_image(self, img_path):
+        """
+        Load an image from the given file path.
+        
+        Args:
+            img_path (str): The file path of the image.
+        
+        Returns:
+            PIL.Image: The loaded image.
+        """
         img = Image.open(img_path).convert('RGB')
         return img
-    def _len__(self):
+    
+    def __len__(self):
+        """
+        Get the total number of images in the dataset.
+        
+        Returns:
+            int: The number of images in the dataset.
+        """
         return len(self.filenames)
+    
     def shuffle_dataset(self):
+        """
+        Shuffle the dataset.
+        """
         if self.shuffle:
             random.shuffle(self.filenames)
-    def _getitem__(self, index):
+    
+    def __getitem__(self, index):
+        """
+        Get the image and its corresponding filename at the given index.
+        
+        Args:
+            index (int): The index of the image in the dataset.
+        
+        Returns:
+            tuple: A tuple containing the image and its filename.
+        """
         if self.load_to_memory:
             img = self.images[index]
         else:
@@ -374,32 +398,7 @@ class MyDataset(Dataset):
         return img, label, filename
 
 class NoClassDataset(Dataset):
-    """
-    A custom dataset class for handling images without class labels.
-
-    Args:
-        data_dir (str): The directory path where the images are stored.
-        transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed version. Default is None.
-        shuffle (bool, optional): Whether to shuffle the dataset. Default is True.
-        load_to_memory (bool, optional): Whether to load all images into memory. Default is False.
-
-    Attributes:
-        data_dir (str): The directory path where the images are stored.
-        transform (callable): A function/transform that takes in an PIL image and returns a transformed version.
-        shuffle (bool): Whether to shuffle the dataset.
-        load_to_memory (bool): Whether to load all images into memory.
-        filenames (list): List of file paths of the images.
-        images (list): List of loaded images (if load_to_memory is True).
-
-    Methods:
-        load_image: Load an image from the given file path.
-        __len__: Get the length of the dataset.
-        shuffle_dataset: Shuffle the dataset.
-        __getitem__: Get an item (image and its filename) from the dataset.
-
-    """
-
-    def _init__(self, data_dir, transform=None, shuffle=True, load_to_memory=False):
+    def __init__(self, data_dir, transform=None, shuffle=True, load_to_memory=False):
         self.data_dir = data_dir
         self.transform = transform
         self.shuffle = shuffle
@@ -409,16 +408,20 @@ class NoClassDataset(Dataset):
             self.shuffle_dataset()
         if self.load_to_memory:
             self.images = [self.load_image(f) for f in self.filenames]
-    #@lru_cache(maxsize=None)
+    
     def load_image(self, img_path):
         img = Image.open(img_path).convert('RGB')
         return img
-    def _len__(self):
+
+    def __len__(self):
+
         return len(self.filenames)
+
     def shuffle_dataset(self):
         if self.shuffle:
             random.shuffle(self.filenames)
-    def _getitem__(self, index):
+
+    def __getitem__(self, index):
         if self.load_to_memory:
             img = self.images[index]
         else:
@@ -427,8 +430,8 @@ class NoClassDataset(Dataset):
             img = self.transform(img)
         else:
             img = ToTensor()(img)
-        # Return both the image and its filename
         return img, self.filenames[index]
+
     
 class TarImageDataset(Dataset):
     def _init__(self, tar_path, transform=None):

spacr/sim.py

@@ -204,16 +204,12 @@ def power_law_dist_gen(df, avg, well_ineq_coeff):
     Generate a power-law distribution for wells.
 
     Parameters:
-    - df: DataFrame
-        The input DataFrame containing the wells.
-    - avg: float
-        The average value for the distribution.
-    - well_ineq_coeff: float
-        The inequality coefficient for the power-law distribution.
+    - df: DataFrame: The input DataFrame containing the wells.
+    - avg: float: The average value for the distribution.
+    - well_ineq_coeff: float: The inequality coefficient for the power-law distribution.
 
     Returns:
-    - dist: ndarray
-        The generated power-law distribution for the wells.
+    - dist: ndarray: The generated power-law distribution for the wells.
     """
     # Generate a power-law distribution for wells
     distribution = generate_power_law_distribution(len(df), well_ineq_coeff)
@@ -405,8 +401,7 @@ def compute_roc_auc(cell_scores):
     - cell_scores (DataFrame): DataFrame containing cell scores with columns 'is_active' and 'score'.
 
     Returns:
-    - cell_roc_dict (dict): Dictionary containing the ROC curve information, including the threshold, true positive rate (TPR),
-                            false positive rate (FPR), and ROC AUC.
+    - cell_roc_dict (dict): Dictionary containing the ROC curve information, including the threshold, true positive rate (TPR), false positive rate (FPR), and ROC AUC.
 
     """
     fpr, tpr, thresh = roc_curve(cell_scores['is_active'], cell_scores['score'], pos_label=1)
@@ -567,11 +562,11 @@ def regression_roc_auc(results_df, active_gene_list, control_gene_list, alpha =
 
     Returns:
     tuple: A tuple containing the following:
-        - results_df (DataFrame): Updated DataFrame with additional columns.
-        - reg_roc_dict_df (DataFrame): DataFrame containing regression ROC curve data.
-        - reg_pr_dict_df (DataFrame): DataFrame containing precision-recall curve data.
-        - reg_cm (ndarray): Confusion matrix.
-        - sim_stats (DataFrame): DataFrame containing simulation statistics.
+    - results_df (DataFrame): Updated DataFrame with additional columns.
+    - reg_roc_dict_df (DataFrame): DataFrame containing regression ROC curve data.
+    - reg_pr_dict_df (DataFrame): DataFrame containing precision-recall curve data.
+    - reg_cm (ndarray): Confusion matrix.
+    - sim_stats (DataFrame): DataFrame containing simulation statistics.
     """
     results_df = results_df.rename(columns={"P>|t|": "p"})
 
@@ -737,20 +732,20 @@ def run_simulation(settings):
 
     Returns:
         tuple: A tuple containing the simulation results and distances.
-            - cell_scores (DataFrame): Scores for each cell.
-            - cell_roc_dict_df (DataFrame): ROC AUC scores for each cell.
-            - cell_pr_dict_df (DataFrame): Precision-Recall AUC scores for each cell.
-            - cell_cm (DataFrame): Confusion matrix for each cell.
-            - well_score (DataFrame): Scores for each well.
-            - gene_fraction_map (DataFrame): Fraction of genes for each well.
-            - metadata (DataFrame): Metadata for each well.
-            - results_df (DataFrame): Results of the regression analysis.
-            - reg_roc_dict_df (DataFrame): ROC AUC scores for each gene.
-            - reg_pr_dict_df (DataFrame): Precision-Recall AUC scores for each gene.
-            - reg_cm (DataFrame): Confusion matrix for each gene.
-            - sim_stats (dict): Additional simulation statistics.
-            - genes_per_well_df (DataFrame): Number of genes per well.
-            - wells_per_gene_df (DataFrame): Number of wells per gene.
+        - cell_scores (DataFrame): Scores for each cell.
+        - cell_roc_dict_df (DataFrame): ROC AUC scores for each cell.
+        - cell_pr_dict_df (DataFrame): Precision-Recall AUC scores for each cell.
+        - cell_cm (DataFrame): Confusion matrix for each cell.
+        - well_score (DataFrame): Scores for each well.
+        - gene_fraction_map (DataFrame): Fraction of genes for each well.
+        - metadata (DataFrame): Metadata for each well.
+        - results_df (DataFrame): Results of the regression analysis.
+        - reg_roc_dict_df (DataFrame): ROC AUC scores for each gene.
+        - reg_pr_dict_df (DataFrame): Precision-Recall AUC scores for each gene.
+        - reg_cm (DataFrame): Confusion matrix for each gene.
+        - sim_stats (dict): Additional simulation statistics.
+        - genes_per_well_df (DataFrame): Number of genes per well.
+        - wells_per_gene_df (DataFrame): Number of wells per gene.
         dists (list): List of distances.
     """
     #try:

spacr/utils.py

@@ -370,12 +370,10 @@ def mask_object_count(mask):
     Counts the number of objects in a given mask.
 
     Parameters:
-    - mask: numpy.ndarray
-        The mask containing object labels.
+    - mask: numpy.ndarray. The mask containing object labels.
 
     Returns:
-    - int
-        The number of objects in the mask.
+    - int. The number of objects in the mask.
     """
     unique_labels = np.unique(mask)
     num_objects = len(unique_labels[unique_labels!=0])
@@ -578,15 +576,15 @@ def normalize_to_dtype(array, p1=2, p2=98):
 
     Parameters:
     - array: numpy array
-        The input stack to be normalized.
+    The input stack to be normalized.
     - p1: int, optional
-        The lower percentile value for normalization. Default is 2.
+    The lower percentile value for normalization. Default is 2.
     - p2: int, optional
-        The upper percentile value for normalization. Default is 98.
+    The upper percentile value for normalization. Default is 98.
 
     Returns:
     - new_stack: numpy array
-        The normalized stack with the same shape as the input stack.
+    The normalized stack with the same shape as the input stack.
     """
     nimg = array.shape[2]
     new_stack = np.empty_like(array, dtype=np.float32)
@@ -1485,52 +1483,18 @@ class SpatialAttention(nn.Module):
     
 # Multi-Scale Block with Attention
 class MultiScaleBlockWithAttention(nn.Module):
-    """
-    Multi-scale block with attention module.
-
-    Args:
-        in_channels (int): Number of input channels.
-        out_channels (int): Number of output channels.
-
-    Attributes:
-        dilated_conv1 (nn.Conv2d): Dilated convolution layer.
-        spatial_attention (nn.Conv2d): Spatial attention layer.
-
-    Methods:
-        custom_forward: Custom forward method for the module.
-        forward: Forward method for the module.
-    """
-
     def __init__(self, in_channels, out_channels):
         super(MultiScaleBlockWithAttention, self).__init__()
         self.dilated_conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, dilation=1, padding=1)
         self.spatial_attention = nn.Conv2d(out_channels, out_channels, kernel_size=1)
         
     def custom_forward(self, x):
-        """
-        Custom forward method for the module.
-
-        Args:
-            x (torch.Tensor): Input tensor.
-
-        Returns:
-            torch.Tensor: Output tensor.
-        """
         x1 = F.relu(self.dilated_conv1(x), inplace=True)
         x = self.spatial_attention(x1)
         return x
 
     def forward(self, x):
-        """
-        Forward method for the module.
-
-        Args:
-            x (torch.Tensor): Input tensor.
-
-        Returns:
-            torch.Tensor: Output tensor.
-        """
-        return checkpoint(self.custom_forward, x)
+        return self.custom_forward(x)
 
 # Final Classifier
 class CustomCellClassifier(nn.Module):
@@ -2258,25 +2222,6 @@ def MLR(merged_df, refine_model):
     
     return max_effects, max_effects_pvalues, model, df
 
-#def normalize_to_dtype(array, q1=2, q2=98, percentiles=None):
-#    if len(array.shape) == 2:
-#        array = np.expand_dims(array, axis=-1)
-#    num_channels = array.shape[-1]
-#    new_stack = np.empty_like(array)
-#    for channel in range(num_channels):
-#        img = array[..., channel]
-#        non_zero_img = img[img > 0]
-#        if non_zero_img.size > 0:
-#            img_min = np.percentile(non_zero_img, q1)
-#            img_max = np.percentile(non_zero_img, q2)
-#        else:
-#            img_min, img_max = (percentiles[channel] if percentiles and channel < len(percentiles)
-#                                else (img.min(), img.max()))
-#        new_stack[..., channel] = rescale_intensity(img, in_range=(img_min, img_max), out_range='dtype')
-#    if new_stack.shape[-1] == 1:
-#        new_stack = np.squeeze(new_stack, axis=-1)
-#    return new_stack
-
 def get_files_from_dir(dir_path, file_extension="*"):
     return glob(os.path.join(dir_path, file_extension))
     
@@ -3875,19 +3820,19 @@ def preprocess_data(df, filter_by, remove_highly_correlated, log_data, exclude):
     applying log transformation, filling NaN values, and scaling the numeric data.
 
     Args:
-        df (pandas.DataFrame): The input dataframe.
-        filter_by (str or None): The channel of interest to filter the dataframe by.
-        remove_highly_correlated (bool or float): Whether to remove highly correlated columns.
-            If a float is provided, it represents the correlation threshold.
-        log_data (bool): Whether to apply log transformation to the numeric data.
-        exclude (list or None): List of features to exclude from the filtering process.
-        verbose (bool): Whether to print verbose output during preprocessing.
+    df (pandas.DataFrame): The input dataframe.
+    filter_by (str or None): The channel of interest to filter the dataframe by.
+    remove_highly_correlated (bool or float): Whether to remove highly correlated columns.
+    If a float is provided, it represents the correlation threshold.
+    log_data (bool): Whether to apply log transformation to the numeric data.
+    exclude (list or None): List of features to exclude from the filtering process.
+    verbose (bool): Whether to print verbose output during preprocessing.
 
     Returns:
-        numpy.ndarray: The preprocessed numeric data.
+    numpy.ndarray: The preprocessed numeric data.
 
     Raises:
-        ValueError: If no numeric columns are available after filtering.
+    ValueError: If no numeric columns are available after filtering.
 
     """
     # Apply filtering based on the `filter_by` parameter
@@ -3927,13 +3872,8 @@ def filter_dataframe_features(df, channel_of_interest, exclude=None):
 
     Parameters:
     - df (pandas.DataFrame): The input dataframe to be filtered.
-    - channel_of_interest (str, int, list, None): The channel(s) of interest to filter the dataframe. 
-      If None, no filtering is applied. If 'morphology', only morphology features are included.
-      If an integer, only the specified channel is included. If a list, only the specified channels are included.
-      If a string, only the specified channel is included.
-    - exclude (str, list, None): The feature(s) to exclude from the filtered dataframe. 
-      If None, no features are excluded. If a string, the specified feature is excluded.
-      If a list, the specified features are excluded.
+    - channel_of_interest (str, int, list, None): The channel(s) of interest to filter the dataframe. If None, no filtering is applied. If 'morphology', only morphology features are included.If an integer, only the specified channel is included. If a list, only the specified channels are included.If a string, only the specified channel is included.
+    - exclude (str, list, None): The feature(s) to exclude from the filtered dataframe. If None, no features are excluded. If a string, the specified feature is excluded.If a list, the specified features are excluded.
 
     Returns:
     - filtered_df (pandas.DataFrame): The filtered dataframe based on the specified parameters.

{spacr-0.0.70.dist-info → spacr-0.0.71.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.0.70
+Version: 0.0.71
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 License-File: LICENSE
-Requires-Dist: dgl
+Requires-Dist: dgl ==0.9.1
 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
@@ -46,6 +46,8 @@ Requires-Dist: opencv-python ; extra == 'full'
 Provides-Extra: headless
 Requires-Dist: opencv-python-headless ; extra == 'headless'
 
+.. |Documentation Status| image:: https://readthedocs.org/projects/spacr/badge/?version=latest
+   :target: https://spacr.readthedocs.io/en/latest/?badge=latest
 .. |PyPI version| image:: https://badge.fury.io/py/spacr.svg
    :target: https://badge.fury.io/py/spacr
 .. |Python version| image:: https://img.shields.io/pypi/pyversions/spacr
@@ -55,25 +57,25 @@ Requires-Dist: opencv-python-headless ; extra == 'headless'
 .. |repo size| image:: https://img.shields.io/github/repo-size/EinarOlafsson/spacr
    :target: https://github.com/EinarOlafsson/spacr/
 
-|PyPI version| |Python version| |Licence: GPL v3| |repo size|
+|Documentation Status| |PyPI version| |Python version| |Licence: GPL v3| |repo size|
 
 SpaCr
 =====
 
-Spatial phenotype analysis of CRISPR-Cas9 screens (SpaCr). The spatial organization of organelles and proteins within cells constitutes a key level of functional regulation. In the context of infectious disease, the spatial relationships between host cell structures and intracellular pathogens are critical to understand host clearance mechanisms and how pathogens evade them. Spacr is a Python-based software package for generating single cell image data for deep-learning sub-cellular/cellular phenotypic classification from pooled genetic CRISPR-Cas9 screens. Spacr provides a flexible toolset to extract single cell images and measurements from high content cell painting experiments, train deep-learning models to classify cellular/subcellular phenotypes, simulate and analyze pooled CRISPR-Cas9 imaging screens.
+Spatial phenotype analysis of CRISPR-Cas9 screens (SpaCr). The spatial organization of organelles and proteins within cells constitutes a key level of functional regulation. In the context of infectious disease, the spatial relationships between host cell structures and intracellular pathogens are critical to understand host clearance mechanisms and how pathogens evade them. SpaCr is a Python-based software package for generating single-cell image data for deep-learning sub-cellular/cellular phenotypic classification from pooled genetic CRISPR-Cas9 screens. SpaCr provides a flexible toolset to extract single-cell images and measurements from high-content cell painting experiments, train deep-learning models to classify cellular/subcellular phenotypes, simulate, and analyze pooled CRISPR-Cas9 imaging screens.
 
 Features
 --------
 
 -  **Generate Masks:** Generate cellpose masks of cell, nuclei, and pathogen objects.
 
--  **Object Measurements:** Measurements for each object including scikit-image-regionprops, intensity percentiles, shannon-entropy, pearsons and manders correlations, homogeneity and radial distribution. Measurements are saved to a SQL database in object level tables.
+-  **Object Measurements:** Measurements for each object including scikit-image-regionprops, intensity percentiles, shannon-entropy, pearsons and manders correlations, homogeneity, and radial distribution. Measurements are saved to a SQL database in object-level tables.
 
--  **Crop Images:** Objects (e.g. cells) can be saved as PNGs from the object area or bounding box area of each object. Object paths are saved in a SQL database that can be annotated and used to train CNNs/Transformer models for classification tasks.
+-  **Crop Images:** Objects (e.g., cells) can be saved as PNGs from the object area or bounding box area of each object. Object paths are saved in a SQL database that can be annotated and used to train CNNs/Transformer models for classification tasks.
 
 -  **Train CNNs or Transformers:** Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images. Train Torch models with IRM/ERM, checkpointing.
 
--  **Manual Annotation:** Supports manual annotation of single cell images and segmentation to refine training datasets for training CNNs/Transformers or cellpose, respectively.
+-  **Manual Annotation:** Supports manual annotation of single-cell images and segmentation to refine training datasets for training CNNs/Transformers or cellpose, respectively.
 
 -  **Finetune Cellpose Models:** Adjust pre-existing Cellpose models to your specific dataset for improved performance.
 
@@ -93,7 +95,7 @@ Requires Tkinter for graphical user interface features.
 Ubuntu
 ~~~~~~
 
-Before installing spacr, ensure Tkinter is installed:
+Before installing SpaCr, ensure Tkinter is installed:
 
 (Tkinter is included with the standard Python installation on macOS, and Windows)